Update markdown to add corrections from recent typo PRs (learnyouahaskell#48)

Thanks, merging!

* Update markdown to match learnyouahaskell#44 and generate markdown HTML for learnyouahaskell#44 and learnyouahaskell#45

* Reflect typo fixes in learnyouahaskell#47 in markdown

Author: xogcox

markdown/generated_html/a-fistful-of-monads.html

@@ -272,7 +272,7 @@ <h2 id="the-monad-type-class">The Monad type class</h2>
 constraint in there along the lines of
 <code>class (Applicative m) = &gt; Monad m where</code> so that a type
 has to be an applicative functor first before it can be made a monad?
-Well, there should, but when Haskell was made, it hadn’t occured to
+Well, there should, but when Haskell was made, it hadn’t occurred to
 people that applicative functors are a good fit for Haskell so they
 weren’t in there. But rest assured, every monad is an applicative
 functor, even if the <code>Monad</code> class declaration doesn’t say

markdown/generated_html/for-a-few-monads-more.html

@@ -74,8 +74,8 @@ <h2 id="writer">Writer? I hardly know her!</h2>
 isBigGang x = x &gt; 9</code></pre>
 <p>Now, what if instead of just giving us a <code>True</code> or
 <code>False</code> value, we want it to also return a log string that
-says what it did? Well, we just make that string and return it along
-side our <code>Bool</code>:</p>
+says what it did? Well, we just make that string and return it alongside
+our <code>Bool</code>:</p>
 <pre class="haskell:hs"><code>isBigGang :: Int -&gt; (Bool, String)
 isBigGang x = (x &gt; 9, &quot;Compared gang size to 9.&quot;)</code></pre>
 <p>So now instead of just returning a <code>Bool</code>, we return a
@@ -376,8 +376,8 @@ <h3 id="adding-logging-to-programs">Adding logging to programs</h3>
 is, we just follow the algorithm outlined. Because 3 isn’t 0, we have to
 find the greatest common divisor of 3 and 2 (if we divide 8 by 3, the
 remainder is 2). Next, we find the greatest common divisor of 3 and 2. 2
-still isn’t 0, so now we have have 2 and 1. The second number isn’t 0,
-so we run the algorithm again for 1 and 0, as dividing 2 by 1 gives us a
+still isn’t 0, so now we have 2 and 1. The second number isn’t 0, so we
+run the algorithm again for 1 and 0, as dividing 2 by 1 gives us a
 remainder of 0. And finally, because the second number is now 0, the
 final result is 1. Let’s see if our code agrees:</p>
 <pre class="haskell:hs"><code>ghci&gt; gcd&#39; 8 3
@@ -680,9 +680,10 @@ <h2 id="reader">Reader? Ugh, not this joke again.</h2>
 then we apply <code>f</code> to that. <code>f</code> returns a monadic
 value, which is a function in our case, so we apply it to <code>w</code>
 as well.</p>
-<p>If don’t get how <code>&gt;&gt;=</code> works at this point, don’t
-worry, because with examples we’ll see how this is a really simple
-monad. Here’s a <code>do</code> expression that utilizes this monad:</p>
+<p>If you don’t understand how <code>&gt;&gt;=</code> works at this
+point, don’t worry, because with examples we’ll see how this is a really
+simple monad. Here’s a <code>do</code> expression that utilizes this
+monad:</p>
 <pre class="haskell:hs"><code>import Control.Monad.Instances
 
 addStuff :: Int -&gt; Int
@@ -794,7 +795,7 @@ <h3 id="stacks-and-stones">Stacks and stones</h3>
 or you can take stuff off the top of the stack. When you’re putting an
 item on top of the stack we say that you’re pushing it to the stack and
 when you’re taking stuff off the top we say that you’re popping it. If
-you want to something that’s at the bottom of the stack, you have to pop
+you want something that’s at the bottom of the stack, you have to pop
 everything that’s above it.</p>
 <p>We’ll use a list to represent our stack and the head of the list will
 be the top of the stack. To help us with our task, we’ll make two
@@ -1030,7 +1031,7 @@ <h3 id="randomness-and-the-state-monad">Randomness and the state
     b &lt;- randomSt
     c &lt;- randomSt
     return (a,b,c)</code></pre>
-<p><code>threeCoins</code> is now a stateful computations and after
+<p><code>threeCoins</code> is now a stateful computation and after
 taking an initial random generator, it passes it to the first
 <code>randomSt</code>, which produces a number and a new generator,
 which gets passed to the next one and so on. We use
@@ -1770,7 +1771,7 @@ <h2 id="making-monads">Making monads</h2>
 while <code>5</code> and <code>9</code> will happen one time out of
 four. Pretty neat.</p>
 <p>We took lists and we added some extra context to them, so this
-represents values withs contexts too. Before we go any further, let’s
+represents values with contexts too. Before we go any further, let’s
 wrap this into a <code>newtype</code> because something tells me we’ll
 be making some instances.</p>
 <pre class="haskell:hs"><code>import Data.Ratio

markdown/generated_html/functionally-solving-problems.html

@@ -38,8 +38,8 @@ <h1 id="functionally-solving-problems">Functionally Solving
 probably won’t be introducing any new concepts, we’ll just be flexing
 our newly acquired Haskell muscles and practicing our coding skills.
 Each section will present a different problem. First we’ll describe the
-problem, then we’ll try and find out what the best (or least worst) way
-of solving it is.</p>
+problem, then we’ll try and find out what the best (or least bad) way of
+solving it is.</p>
 <h2 id="reverse-polish-notation-calculator">Reverse Polish notation
 calculator</h2>
 <p>Usually when we write mathematical expressions in school, we write
@@ -225,7 +225,7 @@ <h2 id="reverse-polish-notation-calculator">Reverse Polish notation
 easily modified to support various other operators. They don’t even have
 to be binary operators. For instance, we can make an operator
 <code>"log"</code> that just pops one number off the stack and pushes
-back its logarithm. We can also make a ternary operators that pop three
+back its logarithm. We can also make ternary operators that pop three
 numbers off the stack and push back a result or operators like
 <code>"sum"</code> which pop off all the numbers and push back their
 sum.</p>
@@ -265,15 +265,16 @@ <h2 id="reverse-polish-notation-calculator">Reverse Polish notation
 <p>I think that making a function that can calculate arbitrary floating
 point RPN expressions and has the option to be easily extended in 10
 lines is pretty awesome.</p>
-<p>One thing to note about this function is that it’s not really fault
-tolerant. When given input that doesn’t make sense, it will just crash
-everything. We’ll make a fault tolerant version of this with a type
-declaration of <code>solveRPN :: String -&gt; Maybe Float</code> once we
-get to know monads (they’re not scary, trust me!). We could make one
-right now, but it would be a bit tedious because it would involve a lot
-of checking for <code>Nothing</code> on every step. If you’re feeling up
-to the challenge though, you can go ahead and try it! Hint: you can use
-<code>reads</code> to see if a read was successful or not.</p>
+<p>One thing to note about this function is that it’s not really
+fault-tolerant. When given input that doesn’t make sense, it will just
+crash everything. We’ll make a fault tolerant version of this with a
+type declaration of <code>solveRPN :: String -&gt; Maybe Float</code>
+once we get to know monads (they’re not scary, trust me!). We could make
+one right now, but it would be a bit tedious because it would involve a
+lot of checking for <code>Nothing</code> on every step. If you’re
+feeling up to the challenge though, you can go ahead and try it! Hint:
+you can use <code>reads</code> to see if a read was successful or
+not.</p>
 <h2 id="heathrow-to-london">Heathrow to London</h2>
 <p>Our next problem is this: your plane has just landed in England and
 you rent a car. You have a meeting really soon and you have to get from

markdown/generated_html/functors-applicative-functors-and-monoids.html

@@ -206,7 +206,7 @@ <h2 id="functors-redux">Functors redux</h2>
 <code>r -&gt; a</code> can be rewritten as <code>(-&gt;) r a</code>,
 much like we can write <code>2 + 3</code> as <code>(+) 2 3</code>. When
 we look at it as <code>(-&gt;) r a</code>, we can see
-<code>(-&gt;)</code> in a slighty different light, because we see that
+<code>(-&gt;)</code> in a slightly different light, because we see that
 it’s just a type constructor that takes two type parameters, just like
 <code>Either</code>. But remember, we said that a type constructor has
 to take exactly one type parameter so that it can be made an instance of
@@ -493,7 +493,7 @@ <h2 id="functors-redux">Functors redux</h2>
 <p>If we use the <code>CNothing</code> constructor, there are no fields,
 and if we use the <code>CJust</code> constructor, the first field is an
 integer and the second field can be any type. Let’s make this an
-instance of <code>Functor</code> so that everytime we use
+instance of <code>Functor</code> so that every time we use
 <code>fmap</code>, the function gets applied to the second field,
 whereas the first field gets increased by 1.</p>
 <pre class="haskell:hs"><code>instance Functor CMaybe where
@@ -844,7 +844,7 @@ <h2 id="applicative-functors">Applicative functors</h2>
 <code>Maybe</code>. There are loads of other instances of
 <code>Applicative</code>, so let’s go and meet them!</p>
 <p>Lists (actually the list type constructor, <code>[]</code>) are
-applicative functors. What a suprise! Here’s how <code>[]</code> is an
+applicative functors. What a surprise! Here’s how <code>[]</code> is an
 instance of <code>Applicative</code>:</p>
 <pre class="haskell:hs"><code>instance Applicative [] where
     pure x = [x]
@@ -1557,14 +1557,14 @@ <h3 id="on-newtype-laziness">On newtype laziness</h3>
 <em>data</em>. The only thing that can be done with <em>newtype</em> is
 turning an existing type into a new type, so internally, Haskell can
 represent the values of types defined with <em>newtype</em> just like
-the original ones, only it has to keep in mind that the their types are
-now distinct. This fact means that not only is <em>newtype</em> faster,
-it’s also lazier. Let’s take a look at what this means.</p>
+the original ones, only it has to keep in mind that the types are now
+distinct. This fact means that not only is <em>newtype</em> faster, it’s
+also lazier. Let’s take a look at what this means.</p>
 <p>Like we’ve said before, Haskell is lazy by default, which means that
 only when we try to actually print the results of our functions will any
-computation take place. Furthemore, only those computations that are
+computation take place. Furthermore, only those computations that are
 necessary for our function to tell us the result will get carried out.
-The <code>undefined</code> value in Haskell represents an erronous
+The <code>undefined</code> value in Haskell represents an erroneous
 computation. If we try to evaluate it (that is, force Haskell to
 actually compute it) by printing it to the terminal, Haskell will throw
 a hissy fit (technically referred to as an exception):</p>
@@ -2227,7 +2227,7 @@ <h3 id="using-monoids-to-fold-data-structures">Using monoids to fold
 folds, the <code class="label class">Foldable</code> type class was
 introduced. Much like <code>Functor</code> is for things that can be
 mapped over, <code>Foldable</code> is for things that can be folded up!
-It can be found in <code>Data.Foldable</code> and because it export
+It can be found in <code>Data.Foldable</code> and because it exports
 functions whose names clash with the ones from the <code>Prelude</code>,
 it’s best imported qualified (and served with basil):</p>
 <pre class="haskell:hs"><code>import qualified Foldable as F</code></pre>
@@ -2307,23 +2307,23 @@ <h3 id="using-monoids-to-fold-data-structures">Using monoids to fold
 whole tree down to one single monoid value? When we were doing
 <code>fmap</code> over our tree, we applied the function that we were
 mapping to a node and then we recursively mapped the function over the
-left sub-tree as well as the right one. Here, we’re tasked with not only
+left subtree as well as the right one. Here, we’re tasked with not only
 mapping a function, but with also joining up the results into a single
 monoid value by using <code>mappend</code>. First we consider the case
 of the empty tree — a sad and lonely tree that has no values or
-sub-trees. It doesn’t hold any value that we can give to our
+subtrees. It doesn’t hold any value that we can give to our
 monoid-making function, so we just say that if our tree is empty, the
 monoid value it becomes is <code>mempty</code>.</p>
 <p>The case of a non-empty node is a bit more interesting. It contains
-two sub-trees as well as a value. In this case, we recursively
+two subtrees as well as a value. In this case, we recursively
 <code>foldMap</code> the same function <code>f</code> over the left and
-the right sub-trees. Remember, our <code>foldMap</code> results in a
+the right subtrees. Remember, our <code>foldMap</code> results in a
 single monoid value. We also apply our function <code>f</code> to the
 value in the node. Now we have three monoid values (two from our
-sub-trees and one from applying <code>f</code> to the value in the node)
+subtrees and one from applying <code>f</code> to the value in the node)
 and we just have to bang them together into a single value. For this
-purpose we use <code>mappend</code>, and naturally the left sub-tree
-comes first, then the node value and then the right sub-tree.</p>
+purpose we use <code>mappend</code>, and naturally the left subtree
+comes first, then the node value and then the right subtree.</p>
 <p>Notice that we didn’t have to provide the function that takes a value
 and returns a monoid value. We receive that function as a parameter to
 <code>foldMap</code> and all we have to decide is where to apply that

markdown/generated_html/higher-order-functions.html

@@ -113,7 +113,7 @@ <h2 id="curried-functions">Curried functions</h2>
 <pre class="haskell:hs"><code>compareWithHundred :: (Num a, Ord a) =&gt; a -&gt; Ordering
 compareWithHundred x = compare 100 x</code></pre>
 <p>If we call it with <code>99</code>, it returns a <code>GT</code>.
-Simple stuff. Notice that the <code>x</code> is on the right hand side
+Simple stuff. Notice that the <code>x</code> is on the right-hand side
 on both sides of the equation. Now let’s think about what
 <code>compare 100</code> returns. It returns a function that takes a
 number and compares it with <code>100</code>. Wow! Isn’t that the
@@ -354,13 +354,14 @@ <h2 id="maps-and-filters">Maps and filters</h2>
 &quot;uagameasadifeent&quot;
 ghci&gt; filter (`elem` [&#39;A&#39;..&#39;Z&#39;]) &quot;i Laugh At you Because u R All The Same&quot;
 &quot;LABRATS&quot;</code></pre>
-<p>All of this could also be achived with list comprehensions by the use
-of predicates. There’s no set rule for when to use <code>map</code> and
-<code>filter</code> versus using list comprehension, you just have to
-decide what’s more readable depending on the code and the context. The
-<code>filter</code> equivalent of applying several predicates in a list
-comprehension is either filtering something several times or joining the
-predicates with the logical <code>&amp;&amp;</code> function.</p>
+<p>All of this could also be achieved with list comprehensions by the
+use of predicates. There’s no set rule for when to use <code>map</code>
+and <code>filter</code> versus using list comprehension, you just have
+to decide what’s more readable depending on the code and the context.
+The <code>filter</code> equivalent of applying several predicates in a
+list comprehension is either filtering something several times or
+joining the predicates with the logical <code>&amp;&amp;</code>
+function.</p>
 <p>Remember our quicksort function from the <a
 href="recursion.html">previous chapter</a>? We used list comprehensions
 to filter out the list elements that are smaller than (or equal to) and
@@ -671,7 +672,7 @@ <h2 id="folds">Only folds and horses</h2>
 <p>If we’re mapping <code>(+3)</code> to <code>[1,2,3]</code>, we
 approach the list from the right side. We take the last element, which
 is <code>3</code> and apply the function to it, which ends up being
-<code>6</code>. Then, we prepend it to the accumulator, which is was
+<code>6</code>. Then, we prepend it to the accumulator, which is
 <code>[]</code>. <code>6:[]</code> is <code>[6]</code> and that’s now
 the accumulator. We apply <code>(+3)</code> to <code>2</code>, that’s
 <code>5</code> and we prepend (<code>:</code>) it to the accumulator, so
@@ -801,8 +802,8 @@ <h2 id="folds">Only folds and horses</h2>
 <p>We use <code>takeWhile</code> here instead of <code>filter</code>
 because <code>filter</code> doesn’t work on infinite lists. Even though
 we know the list is ascending, <code>filter</code> doesn’t, so we use
-<code>takeWhile</code> to cut the scanlist off at the first occurence of
-a sum greater than 1000.</p>
+<code>takeWhile</code> to cut the scanlist off at the first occurrence
+of a sum greater than 1000.</p>
 <h2 id="function-application">Function application with $</h2>
 <p>Alright, next up, we’ll take a look at the <code>$</code> function,
 also called <em>function application</em>. First of all, let’s check out
@@ -827,10 +828,10 @@ <h2 id="function-application">Function application with $</h2>
 keystrokes! When a <code>$</code> is encountered, the expression on its
 right is applied as the parameter to the function on its left. How about
 <code>sqrt 3 + 4 + 9</code>? This adds together 9, 4 and the square root
-of 3. If we want get the square root of <em>3 + 4 + 9</em>, we’d have to
-write <code>sqrt (3 + 4 + 9)</code> or if we use <code>$</code> we can
-write it as <code>sqrt $ 3 + 4 + 9</code> because <code>$</code> has the
-lowest precedence of any operator. That’s why you can imagine a
+of 3. If we want to get the square root of <em>3 + 4 + 9</em>, we’d have
+to write <code>sqrt (3 + 4 + 9)</code> or if we use <code>$</code> we
+can write it as <code>sqrt $ 3 + 4 + 9</code> because <code>$</code> has
+the lowest precedence of any operator. That’s why you can imagine a
 <code>$</code> being sort of the equivalent of writing an opening
 parentheses and then writing a closing one on the far right side of the
 expression.</p>
@@ -921,8 +922,8 @@ <h2 id="composition">Function composition</h2>
 the function as <code>sum' = foldl (+) 0</code> is called writing it in
 point free style. How would we write this in point free style?</p>
 <pre class="haskell:hs"><code>fn x = ceiling (negate (tan (cos (max 50 x))))</code></pre>
-<p>We can’t just get rid of the <code>x</code> on both right right
-sides. The <code>x</code> in the function body has parentheses after it.
+<p>We can’t just get rid of the <code>x</code> on both right sides. The
+<code>x</code> in the function body has parentheses after it.
 <code>cos (max 50)</code> wouldn’t make sense. You can’t get the cosine
 of a function. What we can do is express <code>fn</code> as a
 composition of functions.</p>
@@ -935,7 +936,7 @@ <h2 id="composition">Function composition</h2>
 writing a function in point free style can be less readable if a
 function is too complex. That’s why making long chains of function
 composition is discouraged, although I plead guilty of sometimes being
-too composition-happy. The prefered style is to use <em>let</em>
+too composition-happy. The preferred style is to use <em>let</em>
 bindings to give labels to intermediary results or split the problem
 into sub-problems and then put it together so that the function makes
 sense to someone reading it instead of just making a huge composition