higher-order-functions

What is the difference of the following two function definitions in Scala: 1) def sum(f: Int => Int)(a: Int, b: Int): Int = { <code removed> } 2) def sum(f: Int => Int, a: Int, b: Int): Int = { <code removed> } ? SBT's console REPL gives different value for them so looks if they are somehow different: sum: (f: Int => Int, a: Int, b: Int)Int sum: (f: Int => Int)(a: Int, b: Int)Int The first definition is curried , so that you can provide a and b at another time. For instance, if you know the function you want to use in the current method, but don't yet know the arguments, you can use it so: def

As You may know, there are higher order functions in OCaml, such as fold_left, fold_right, filter etc. On my course in functional programming had been introduced function named fold_tree, which is something like fold_left/right, not on lists, but on (binary) trees. It looks like this: let rec fold_tree f a t = match t with Leaf -> a | Node (l, x, r) -> f x (fold_tree f a l) (fold_tree f a r);; Where tree is defined as: type 'a tree = Node of 'a tree * 'a * 'a tree | Leaf;; OK, here's my question: how does the fold_tree function work? Could you give me some examples and explain in human

I have created LoadBookHOC which is wrapped with BookDetails and BookSummary component. LoadBookHOC.js const LoadBookHOC = InnerComponent => class LoadBook extends React.Component { constructor(){ super(); this.state={ book: [] }; } set= obj => this.setState(obj); render(){ return( <InnerComponent {...this.props} hocState={this.state} hocSetState={this.set} /> ); } } BookDetails.js this.hocSetState({book: <new data>}); BookSummary.js this.hocSetState({book: <new data>}); Whenever this.props.hocState.book called in BookDetails or BookSummary , I need to get the same data. I mean all the

For example, how can I write a version of map that will work with polymorphic functions in Typed Racket? I use a simple id function defined as: (: id : (All (A) A -> A)) (define (id x) x) When I try to map it over a list i get an error: > (map id '(1 2 3)) Type Checker: Polymorphic function `map' could not be applied to arguments: Types: (-> a b ... b c) (Listof a) (Listof b) ... b -> (Listof c) (-> a c) (Pairof a (Listof a)) -> (Pairof c (Listof c)) Arguments: (All (A) (-> A A)) (List One Positive-Byte Positive-Byte) Expected result: AnyValues in: (map id (quote (1 2 3))) You have to manually

I am a beginner interested in Haskell, and I have been trying to implement the flatmap (>>=) on my own to better understand it. Currently I have flatmap :: (t -> a) -> [t] -> [a] flatmap _ [] = [] flatmap f (x:xs) = f x : flatmap f xs which implements the "map" part but not the "flat". Most of the modifications I make result in the disheartening and fairly informationless Occurs check: cannot construct the infinite type: a = [a] When generalising the type(s) for `flatmap' error. What am I missing? An error like this happens when the type signature you specify does not match the actual type of