Differences

This shows you the differences between two versions of the page.

--- codesnippets:folds [2021/04/08 12:57] – f2b216
+++ codesnippets:folds [2025/10/08 00:48] (current) – external edit 127.0.0.1
@@ Line 323: / Line 323: @@
 ====== Keeping order and beeing fast? ======
-The implications regarding order of execution:
+  * use case
+    * finite lists
+    * large lists
+    * order of operations to be kept as is foldr
   * example, using foldr:<code Haskell>
+main :: IO ()
+main =
+    do
+        print $ f1 lnNumbers1
+        print $ f1 lnNumbers2
+        print $ f1 lnNumbers3
+lnNumbers1 = [31,13]
+lnNumbers2 = [31,13,3]
+lnNumbers3 = [1..100000000]
+f1 :: [Integer] -> Integer
+f1 ln = foldr (-) 0 ln
+</code>
+    * executes, with output:<code>
+-50000000
+</code>
+    * executes within approximately __**15 seconds**__ on Intel(R) Core(TM) i5-8400 @ 2.80GHz
+    * executes using large heap space
+      * {{:codesnippets:heapconsumptionfoldronnoncommutativeop.png?200|}}
+  * example, using ''foldl'' and ''reverse'':<code Haskell>
+import qualified Data.List as L
+main :: IO ()
+main =
+    do
+        print $ f2 lnNumbers1
+        print $ f2 lnNumbers2
+        print $ f2 lnNumbers3
+lnNumbers1 = [31,13]
+lnNumbers2 = [31,13,3]
+lnNumbers3 = [1..100000000]
+f2 :: [Integer] -> Integer
+f2 ln = foldlFlpRvrs (-) 0 ln
+foldlFlpRvrs :: (a -> b -> b) -> b -> [a] -> b
+foldlFlpRvrs f initial l = L.foldl' (flip f) initial (reverse l)
+</code>
+    * executes, with output:<code>
+-50000000
+</code>
+    * executes within approximately __**15 seconds**__ on Intel(R) Core(TM) i5-8400 @ 2.80GHz
+    * executes using large heap space
+      * {{:codesnippets:heapconsumptionfoldlfronnoncommutativeop.png?200|}}
+      * regardless of whether ''L.foldl' '' or ''foldl'' is used
+      * regardless of whether alternative ''reverse'' functions are implemented
+        * e.g.:<code Haskell>
+reverse' :: [a] -> [a]
+reverse' (x:rlx) = reverse'' [x] rlx
+    where
+        reverse'' :: [a] -> [a] -> [a]
+        reverse'' lxReverse [] = lxReverse
+        reverse'' lxReverse (x:rlx) = reverse'' (x : lxReverse) rlx
+</code>
+        * or<code Haskell>
+reverse' :: [a] -> [a]
+reverse' l = foldl (flip (:)) [] l
+</code>
+        * or<code Haskell>
+reverse' :: [a] -> [a]
+reverse' l = L.foldl' (flip (:)) [] l
+</code>
 ====== Conclusion and selection ======
@@ Line 333: / Line 403: @@
     * if the initial value needs to be evaluated first -> use ''foldl' '', but...
       * if the initial value also is the first and the last respectively use ''foldl1' ''
-  * if the order should be kept, and the list finite, but large -> use ''foldl'' with flipped parameter and reverse list
-    * <code Haskell>
-foldlFlpRvrs :: (a -> b -> b) -> b -> [a] -> b
-foldlFlpRvrs f i l = foldl (flip f) i (reverse l)
-<code>
   * if the order should be kept or if for infinite lists -> use ''foldr'', but...
       * if the initial value is the first and the last respectively use ''foldr1''
+===== ✎ =====
+~~DISCUSSION~~