various

Author: MatthijsBlom

source_md/higher-order-functions.md

@@ -796,14 +796,14 @@ ghci> scanl (flip (:)) [] [3,2,1]
 When using a `scanl`, the final result will be in the last element of the resulting list while a `scanr` will place the result in the head.
 
 Scans are used to monitor the progression of a function that can be implemented as a fold.
-Let's answer us this question: **How many elements does it take for the sum of the square roots of all natural numbers to exceed 1000?**
+Let's answer us this question: **How many elements does it take for the sum of the square roots of all natural numbers to exceed $1000$?**
 To get the square roots of all natural numbers, we just do `map sqrt [1..]`.
 Now, to get the sum, we could do a fold, but because we're interested in how the sum progresses, we're going to do a scan.
-Once we've done the scan, we just see how many sums are under 1000.
-The first sum in the scanlist will be 1, normally.
-The second will be 1 plus the square root of 2.
-The third will be that plus the square root of 3.
-If there are X sums under 1000, then it takes X+1 elements for the sum to exceed 1000.
+Once we've done the scan, we just see how many sums are under $1000$.
+The first sum in the scanlist will be $1$, normally.
+The second will be $1 + \sqrt 2$.
+The third will be $1 + \sqrt 2 + \sqrt 3$.
+If there are $n$ sums under 1000, then it takes $n + 1$ elements for the sum to exceed $1000$.
 
 ```{.haskell:hs}
 sqrtSums :: Int
@@ -820,7 +820,7 @@ ghci> sum (map sqrt [1..130])
 ```
 
 We use `takeWhile` here instead of `filter` because `filter` doesn't work on infinite lists.
-Even though we know the list is ascending, `filter` doesn't, so we use `takeWhile` to cut the scanlist off at the first occurrence of a sum greater than 1000.
+Even though we know the list is ascending, `filter` doesn't, so we use `takeWhile` to cut the scanlist off at the first occurrence of a sum greater than $1000$.
 
 ## Function application with $ {#function-application}
 

source_md/starting-out.md

@@ -884,7 +884,7 @@ ghci> triangles = [ (a,b,c) | c <- [1..10], a <- [1..10], b <- [1..10] ]
 We're just drawing from three lists and our output function is combining them into a triple.
 If you evaluate that by typing out `triangles` in GHCi, you'll get a list of all possible triangles with sides under or equal to 10.
 Next, we'll add a condition that they all have to be right triangles.
-We'll also modify this function by taking into consideration that side *a* isn't larger than the hypotenuse and that side *b* isn't larger than side *a*.
+We'll also modify this function by taking into consideration that side $a$ isn't larger than the hypotenuse and that side $b$ isn't larger than side $a$.
 
 ```{.haskell: .ghci}
 ghci> rightTriangles = [ (a,b,c) | c <- [1..10], a <- [1..c], b <- [1..a], a^2 + b^2 == c^2]

source_md/syntax-in-functions.md

@@ -91,7 +91,7 @@ When making patterns, we should always include a catch-all pattern so that our p
 
 Pattern matching can also be used on tuples.
 What if we wanted to make a function that takes two vectors in a 2D space (that are in the form of pairs) and adds them together?
-To add together two vectors, we add their x components separately and then their y components separately.
+To add together two vectors, we add their $x$ components separately and then their $y$ components separately.
 Here's how we would have done it if we didn't know about pattern matching:
 
 ```{.haskell:hs}