fold

I am puzzled. I can write this: import Control.Monad main = print $ head $ (foldr (.) id [f, g]) [3] where f = (1:) g = undefined and the output is 1 . That makes sense, because it reduces to: main = print $ head $ ((1:) . undefined . id) [3] main = print $ head $ (1:) ((undefined . id) [3]) main = print $ head $ 1 : ((undefined . id) [3]) main = print $ 1 But if I use a vaguely similar monadic technique, it doesn't work the same: import Control.Monad main = print $ (foldr (<=<) return [f, g]) 3 where f = const Nothing g = undefined This hits prelude.Undefined . Which is odd, because I would

According to http://en.wikipedia.org/wiki/Fold_(higher-order_function ), a right fold can operate on infinite lists if the full list does not have to be evaluated. This can be seen in action in haskell: Prelude> take 5 (foldr (:) [] [1 ..]) [1,2,3,4,5] This does not seem to work well in scala for streams: Stream.from(1).foldRight(Stream.empty[Int])( (i, s) => i #:: s).take(5) // StackOverflowError or on iterators: Iterator.from(1).foldRight(Iterator.empty: Iterator[Int]){ (i, it) => Iterator.single(i) ++ it }.take(5) // OutOfMemoryError: Java heap space Is there a practical solution to achieve

I am going through basics of Kotlin and I am pretty confused with this both functions fold() and reduce() in Kotlin, can anyone give me a concrete example which distinguishes both of them? fold takes an initial value, and the first invocation of the lambda you pass to it will receive that initial value and the first element of the collection as parameters. For example, take the following code that calculates the sum of a list of integers: listOf(1, 2, 3).fold(0) { sum, element -> sum + element } The first call to the lambda will be with parameters 0 and 1 . Having the ability to pass in an

I have learned the basic difference between foldLeft and reduceLeft foldLeft: initial value has to be passed reduceLeft: takes first element of the collection as initial value throws exception if collection is empty Is there any other difference ? Any specific reason to have two methods with similar functionality? Few things to mention here, before giving the actual answer: Your question doesn't have anything to do with left , it's rather about the difference between reducing and folding The difference is not the implementation at all, just look at the signatures. The question doesn't have

I want to be able to sum the squares of the even elements in the list, however my current code only sums the elements, not the squares. Does anyone know of any modifications that can be made to make this to sum the squares of the even-valued elements in the list? (define (sum elemList) (if (null? elemList) 0 (+ (car elemList) (sum (cdr elemList))) ) ) My input would be: (sum-evens (list 1 2 3 4)) Output would be: 20 Which is (2*2) + (4*4) . If possible, it would be good to see both a recursive and iterative solution. Any ideas? There are two possibilities, either we implement the recursion

I learning more and more about Erlang language and have recently faced some problem. I read about foldl(Fun, Acc0, List) -> Acc1 function. I used learnyousomeerlang.com tutorial and there was an example (example is about Reverse Polish Notation Calculator in Erlang): %function that deletes all whitspaces and also execute rpn(L) when is_list(L) -> [Res] = lists:foldl(fun rpn/2, [], string:tokens(L," ")), Res. %function that converts string to integer or floating poitn value read(N) -> case string:to_float(N) of %returning {error, no_float} where there is no float avaiable {error,no_float} ->

I am trying to get the product of a tree by using the fold function so far this is what I have. I am confused on how to use the fold method while transversing the tree datatype 'a bin_tree = Leaf of 'a | Node of 'a bin_tree * 'a bin_tree fun treefold g z Empty = z | treefold g z (Node (l, x, r)) = g(x, g(treefold g z l, treefold g z r) First, some pointers about what isn't quite in order in your attempt. The base case of your treefold function matches against the value constructor Empty , but you don't define the bin_tree datatype to include an Empty value constructor. As John Coleman points

My understanding of the difference between List.fold and List.foldBack is that foldBack iterates over its list in a reverse order. Both functions accumulate a result from the items in the list. I'm having trouble coming up with a good example where it is preferable to foldBack over a list. In the examples I have come up with, the results are the same for both fold and foldBack, if the function logic does the same thing. [<Fact>] let ``List.foldBack accumulating a value from the right to the left``() = let list = [1..5] let fFoldBack x acc = acc - x let fFold acc x = acc - x let foldBackResult