Differences

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

--- codesnippets:folds [2021/04/08 13:00] – [Keeping order and beeing fast?] 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 ()
@@ Line 330: / Line 333: @@
         print $ f1 lnNumbers1
         print $ f1 lnNumbers2
-        print $ f2 lnNumbers1
+        print $ f1 lnNumbers3
-        print $ f2 lnNumbers2
+lnNumbers1 = [31,13]
+lnNumbers2 = [31,13,3]
+lnNumbers3 = [1..100000000]
-lnNumbers1 = [31,13,3]
-lnNumbers2 = [1..10000000]
 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 = foldl (flip f) initial (reverse l)
+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 353: / 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~~