Various bug fixes and clarifications in Approaches (#1175)

* Various bug fixes and clarifications

* Update content.md

Author: MatthijsBlom

exercises/practice/bob/.approaches/string/content.md

@@ -58,21 +58,28 @@ How do these work?
 
 ~~~~exercism/advanced
 To find they actual definitions of `any` and `all`, look up their documentation (for example through [Hoogle][hoogle]) and click on the «Source» link next to the type signature.
+
 The definitions of `any` and `all` look kinda complicated!
 They are this way so that they can also be used on types other than lists, such as `Set`, `Map`, and `Tree`.
 Specifically, they can be used on any type that is an instance of the `Foldable` type class.
+
 In the source code, you can click on names to jump to their definitions.
 This doesn't really work for `foldMap` here though: it sends you to its default (general) implementation, but here we need its implementation for lists specifically.
 To find that code, navigate to the documentation of `Foldable`, look up `[]` in the list of «Instances», and click «Source».
+
 It might be hard to see – even after lots of clicking through to definitions – but these definitions of `any` and `all` work essentially the same way as the one outlined here below.
-[hoogle]: https://hoogle.haskell.org/ "Hoogle"
+
+[hoogle]:
+    https://hoogle.haskell.org/
+    "Hoogle"
 ~~~~
 
 Here is a possible definition of `any`:
 
 ```haskell
 or :: [Bool] -> Bool
 or = foldr (||) True
+
 any p = or . map p
 ```
 

exercises/practice/bob/.approaches/text/content.md

@@ -33,10 +33,10 @@ dependencies:
 Thereafter you can import functions as you would normally:
 
 ```haskell
--- these names can be used by themselves
+-- allow using the following names by themselves
 import Data.Text (Text, strip, unsnoc)
 
--- all other names from `Data.Text` need to be prefixed with `Text.`
+-- require all other names from `Data.Text` to be prefixed with `Text.`
 import qualified Data.Text as Text
 ```
 
@@ -131,8 +131,8 @@ minimum unsorted =
 
 This is a bit more verbose.
 But more importantly it introduces an extra name: `unsorted`.
-We intend to use only once (to `sort` it), but we might use it in more places by accident.
+We intend to use it only once (to `sort` it), but we might accidentally use it in more places.
 By eliminating the need for an extra name, the view pattern makes it impossible to make this mistake.
 
 The solution highlighted above uses a view pattern to remove initial and trailing spaces from the input.
-That way, `isSilent` and `isQuestion` need not do it themselves anymore, or the introduction of an otherwise unnecessary name is avoided.
+That way, `isSilent` and `isQuestion` need not do it themselves anymore, or the introduction of an otherwise unnecessary name (for the stripped query) is avoided.

exercises/practice/collatz-conjecture/.approaches/list-of-steps/content.md

@@ -89,7 +89,7 @@ This is the only logic that is provided by us instead of by the standard library
 The sequence of steps should be terminated at the first `1`.
 `unfoldr` does this by itself, but `iterate` needs some help from `takeWhile`.
 
-With a complete sequence of steps, the only thing that remains to be done is count them.
+With a complete sequence of steps, the only thing that remains to be done is to count them.
 We simply use `length` for this.
 
 Haskell's laziness helps this approach be efficient.

exercises/practice/collatz-conjecture/.approaches/recursion/content.md

@@ -74,7 +74,7 @@ Instead, all 'loopiness' in Haskell is produced through recursion – if not
 ## In this approach
 
 First, we compare the input with `1`.
-If it is less than `1` the input is invalid and we return `Nothing`.
+If it is less than `1` then the input is invalid and we return `Nothing`.
 If it is exactly `1`, then the number of steps it takes to reach `1` is zero – because we're already there – so we return `Just 0`.
 
 If the input is greater than `1`, it'll take at least one step to get to `1`.

exercises/practice/collatz-conjecture/.approaches/worker-wrapper/content.md

@@ -22,9 +22,9 @@ However, variables do not exist in Haskell: all bindings are constants.
 
 In lieu of local variables we can add extra parameters to our functions.
 These will hold our state.
-'Changing' of the state is done by calling the same functions with different arguments.
+'Changing' the state is done by calling the same functions (recursively) with different arguments.
 
-Functions that uses such additional parameters to represent state are often called _workers_, and functions that use them are often called _wrappers_.
+Functions that uses such additional parameters to represent state are often called _workers_, and functions that use workers to solve a problem in a stateful way are often called _wrappers_.
 
 As an example, consider the following possible definition of `length`.
 
@@ -98,7 +98,7 @@ For a few more more examples, see the [relevant wiki article][wiki-worker-wrappe
 ## Bang patterns
 
 The above implementation of `length'` _might_ evaluate as efficiently as illustrated.
-However, it also might not!
+However, depending on which optimization opportunities are spotted by the compiler, it also might not!
 The definition of `length'` allows evaluation to proceed as follows as well.
 
 ```haskell
@@ -122,11 +122,12 @@ The situation is not quite as bad as before though.
 In the case of the naive implementation of `length`, the built up expression has the form
 
 ```haskell
-_ = 1 + (1 + (⋯(1 + length xs)⋯))
+_ = 1 + (1 + (⋯(1 + length …)⋯))
 ```
 
-This expression cannot be simplified before `length xs` has been evaluated.
-As a consequence, it must grow as big as the original list.
+This expression cannot be simplified before `length …` has been evaluated.
+That is, simplification cannot begin until the last recursive step has been evaluated.
+As a consequence, the computation must grow as big as the original list.
 
 The computation built up by `length'` on the other hand has the form
 
@@ -141,7 +142,7 @@ Haskell offers various ways to force intermediate evaluation.
 One convenient tool is the _bang pattern_, enabled by the `BangPatterns` language extension.
 
 ```haskell
-{-# LANGUAGE BangPatterns #-}  -- at the top of the file
+{-# LANGUAGE BangPatterns #-}  -- 👈 at the top of the file
 
 length'' :: Int -> [a] -> Int
 length'' !count []     = count

exercises/practice/hamming/.approaches/introduction.md

@@ -50,7 +50,7 @@ You can use `fmap`/`<$>` for this.
 [Read more about this approach][recursion]
 
 
-## Approach: a worker&wrapper construct
+## Approach: a worker&ndash;wrapper construct
 
 ```haskell
 distance :: String -> String -> Maybe Int

exercises/practice/hamming/.approaches/worker-wrapper/content.md

@@ -21,9 +21,9 @@ However, variables do not exist in Haskell: all bindings are constants.
 
 In lieu of local variables we can add extra parameters to our functions.
 These will hold our state.
-'Changing' of the state is done by calling the same functions with different arguments.
+'Changing' the state is done by calling the same functions (recursively) with different arguments.
 
-Functions that uses such additional parameters to represent state are often called _workers_, and functions that use them are often called _wrappers_.
+Functions that uses such additional parameters to represent state are often called _workers_, and functions that use workers to solve a problem in a stateful way are often called _wrappers_.
 
 As an example, consider the following possible definition of `length`.
 
@@ -97,7 +97,7 @@ For a few more more examples, see the [relevant wiki article][wiki-worker-wrappe
 ## Bang patterns
 
 The above implementation of `length'` _might_ evaluate as efficiently as illustrated.
-However, it also might not!
+However, depending on which optimization opportunities are spotted by the compiler, it also might not!
 The definition of `length'` allows evaluation to proceed as follows as well.
 
 ```haskell
@@ -121,11 +121,12 @@ The situation is not quite as bad as before though.
 In the case of the naive implementation of `length`, the built up expression has the form
 
 ```haskell
-_ = 1 + (1 + (⋯(1 + length xs)⋯))
+_ = 1 + (1 + (⋯(1 + length …)⋯))
 ```
 
-This expression cannot be simplified before `length xs` has been evaluated.
-As a consequence, it must grow as big as the original list.
+This expression cannot be simplified before `length …` has been evaluated.
+That is, simplification cannot begin until the last recursive step has been evaluated.
+As a consequence, the computation must grow as big as the original list.
 
 The computation built up by `length'` on the other hand has the form
 
@@ -140,7 +141,7 @@ Haskell offers various ways to force intermediate evaluation.
 One convenient tool is the _bang pattern_, enabled by the `BangPatterns` language extension.
 
 ```haskell
-{-# LANGUAGE BangPatterns #-}  -- at the top of the file
+{-# LANGUAGE BangPatterns #-}  -- 👈 at the top of the file
 
 length'' :: Int -> [a] -> Int
 length'' !count []     = count