Adjust details

Author: Xingye-Dujing

source_md/higher-order-functions.md

@@ -673,7 +673,7 @@ 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!
 
 **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.**
@@ -697,12 +697,12 @@ 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,...])` $\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**.
+- Start: `foldr (...) False [1,2,3,4,...]`  
+- For `x = 1`: `if 1 == 3 then True else (foldr (...) False [2,3,4,...])`. Since `1 == 3` is `False`, the expression becomes `foldr (...) False [2,3,4,...]` (we recurse).  
+- For `x = 2`: `if 2 == 3 then True else (foldr (...) False [3,4,5,...])`. Since `2 == 3` is `False`, the expression becomes `foldr (...) False [3,4,5,...]` (we recurse again).  
+- For `x = 3`: `if 3 == 3 then True else (foldr (...) False [4,5,6,...])`. Since `3 == 3` is `True`, **`f` ignores the recursive call (the `[4,5,6,...]` part) and returns `True` immediately**.
 
-<br>Now, contrast this with `foldl`'s definition:
+Now, contrast this with `foldl`'s definition:
 
 ```{.haskell:hs}
 foldl f acc []     = acc
@@ -720,14 +720,14 @@ 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` $\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.
+- Start: `acc = False`, list `[1,2,3,4,...]`.  
+- Compute `f False 1`, which evaluates to `if 1 == 3 then True else False`, resulting in `False`. Recurse: `foldl (...) False [2,3,4,...]`.  
+- Compute `f False 2`, which results in `False`. Recurse: `foldl (...) False [3,4,5,...]`.  
+- Compute `f False 3`, which results in `True`. But now we must recurse: `foldl (...) True [4,5,6,...]`.  
+- Compute `f True 4`, which results in `True` (since `4 == 3` is `False`, it returns the accumulator `True`). But we recurse again: `foldl (...) True [5,6,7,...]`.  
+- This continues forever. Even though we found `3`, we never stop.
 
-<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 `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**.