Divide into two subsections

Author: Xingye-Dujing

source_md/higher-order-functions.md

@@ -673,18 +673,22 @@ It would be `map' f xs = foldl (\acc x -> acc ++ [f x]) [] xs`, but the thing is
 If you reverse a list, you can do a right fold on it just like you would have done a left fold and vice versa.
 Sometimes you don't even have to do that.
 The `sum` function can be implemented pretty much the same with a left and right fold.
-*One big difference is that right folds work on infinite lists, whereas left ones don't!*
+**One big difference is that right folds work on infinite lists, whereas left ones don't!**
 
-How `foldr` works with infinite lists? Recall the definition of `foldr`:
+**Folds can be used to implement any function where you traverse a list once, element by element, and then return something based on that.
+Whenever you want to traverse a list to return something, chances are you want a fold.**
+That's why folds are, along with maps and filters, one of the most useful types of functions in functional programming.
+
+### Why `foldr` works on infinite lists while `foldl` doesn't
+
+Recall the definition of `foldr`:
 
 ```{.haskell:hs}
 foldr f acc []     = acc
 foldr f acc (x:xs) = f x (foldr f acc xs)
 ```
 
-The key insight is that the recursive call `foldr f acc xs` is passed as an argument to the function `f`. Because Haskell is lazy, if `f` never uses its second argument, the recursive call is never evaluated. This allows `foldr` to terminate on infinite lists, provided `f` is lazy in its right argument.
-
-Example: Checking for a Value in an infinite list. Suppose we want to check if `3` appears in an infinite list `[1..]`. We can use `foldr` like this:
+The key insight is that the recursive call `foldr f acc xs` is passed as an argument to the function `f`. Because Haskell is lazy, if `f` never uses its second argument, the recursive call is never evaluated. This allows `foldr` to terminate on infinite lists, provided `f` is lazy in its right argument. For example, we want to check if `3` appears in an infinite list `[1..]`. We can use `foldr` like this:
 
 ```{.haskell:hs}
 containsThree :: [Int] -> Bool
@@ -694,20 +698,20 @@ containsThree = foldr (\x rest -> if x == 3 then True else rest) False
 Let's unfold this step-by-step on the infinite list `[1,2,3,4,...]`:
 
 1. Start: `foldr (...) False [1,2,3,4,...]`
-2. For `x=1`: `if 1 == 3 then True else (foldr (...) False [2,3,4,...])` -> `1 /= 3`, so this becomes `foldr (...) False [2,3,4,...]` (we recurse).
-3. For `x=2`: `if 2 == 3 then True else (foldr (...) False [3,4,5,...])` -> `2 /= 3`, so this becomes `foldr (...) False [3,4,5,...]` (we recurse again).
-4. For `x=3`: `if 3 == 3 then True else (foldr (...) False [4,5,6,...])` -> `3 == 3` is `True`! *Here, `f` ignores the recursive call (the [4,5,6,...] part) and returns True immediately*.
+2. For `x = 1`: `if 1 == 3 then True else (foldr (...) False [2,3,4,...])` $\to$ `1 /= 3`, so this becomes `foldr (...) False [2,3,4,...]` (we recurse).
+3. For `x = 2`: `if 2 == 3 then True else (foldr (...) False [3,4,5,...])` $\to$ `2 /= 3`, so this becomes `foldr (...) False [3,4,5,...]` (we recurse again).
+4. For `x = 3`: `if 3 == 3 then True else (foldr (...) False [4,5,6,...])` $\to$ `3 == 3` is `True`! **Here, `f` ignores the recursive call (the `[4,5,6,...]` part) and returns `True` immediately**.
 
-Why `foldl` Fails with Infinite Lists? Now, contrast this with `foldl`'s definition:
+<br>Now, contrast this with `foldl`'s definition:
 
 ```{.haskell:hs}
 foldl f acc []     = acc
 foldl f acc (x:xs) = foldl f (f acc x) xs
 ```
 
 Notice that `foldl` always makes a recursive call first, passing `f acc x` as the new accumulator. This means:
-Even if the accumulator becomes True at some point, foldl will still continue recursing down the list.
-For an infinite list, this leads to infinite recursion (it never stops). If we try to implement containsThree with `foldl`:
+Even if the accumulator becomes `True` at some point, `foldl` will still continue recursing down the list.
+For an infinite list, this leads to infinite recursion (it never stops). If we try to implement `containsThree` with `foldl`:
 
 ```{.haskell:hs}
 containsThreeFoldl :: [Int] -> Bool
@@ -716,20 +720,18 @@ containsThreeFoldl = foldl (\acc x -> if x == 3 then True else acc) False
 
 Unfolding on `[1,2,3,4,...]`:
 
-1. Start: `acc = False`, list [1,2,3,4,...].
-3. Compute `f False 1` -> `if 1==3 then True else False` -> `False`. Recurse: `foldl (...) False [2,3,4,...]`.
-4. Compute `f False 2` -> `False`. Recurse: `foldl (...) False [3,4,5,...]`.
-5. Compute `f False 3` -> `True`. But now we must recurse: `foldl (...) True [4,5,6,...]`.
-6. Compute `f True 4` -> `True` (since 4 /= 3, it returns the accumulator True). But we recurse again: `foldl (...) True [5,6,7,...]`.
-7. This continues forever. Even though we found 3, we never stop.
+1. Start: `acc = False`, list `[1,2,3,4,...]`.
+3. Compute `f False 1` $\to$ `if 1==3 then True else False` $\to$ `False`. Recurse: `foldl (...) False [2,3,4,...]`.
+4. Compute `f False 2` $\to$ `False`. Recurse: `foldl (...) False [3,4,5,...]`.
+5. Compute `f False 3` $\to$ `True`. But now we must recurse: `foldl (...) True [4,5,6,...]`.
+6. Compute `f True 4` $\to$ `True` (since `4 /= 3`, it returns the accumulator `True`). But we recurse again: `foldl (...) True [5,6,7,...]`.
+7. This continues forever. Even though we found `3`, we never stop.
 
-The `foldr` function can terminate on infinite lists if the function `f` is lazy in its right argument (i.e., `f` can short-circuit by ignoring the recursive result).
+<br>The `foldr` function can terminate on infinite lists if the function `f` is lazy in its right argument (i.e., `f` can short-circuit by ignoring the recursive result).
 The `foldl` function always processes the list from left to right and cannot short-circuit in the same way, so it fails on infinite lists.
-This is why `foldr` is often more suitable for working with infinite lists. Just remember: *the function `f` must be lazy in its right argument for `foldr` to terminate early*.
+This is why `foldr` is often more suitable for working with infinite lists. Just remember: **the function `f` must be lazy in its right argument for `foldr` to terminate early**.
 
-**Folds can be used to implement any function where you traverse a list once, element by element, and then return something based on that.
-Whenever you want to traverse a list to return something, chances are you want a fold.**
-That's why folds are, along with maps and filters, one of the most useful types of functions in functional programming.
+### Other folds
 
 The `foldl1`{.label .function} and `foldr1`{.label .function} functions work much like `foldl` and `foldr`, only you don't need to provide them with an explicit starting value.
 They assume the first (or last) element of the list to be the starting value and then start the fold with the element next to it.