Grammar typos spelling flow (#70)

* "occurences" -> "occurrences"

* "glueing" -> "gluing"

* "lenghts" -> "lengths"

* "hypothenuse" -> "hypotenuse"

* "auxilliary" -> "auxiliary"

* "Pure code can throw exceptions, but it they can..." -> "Pure code can throw exceptions, but they can..."

* "less bugs" -> "fewer bugs" (countable nouns use "fewer" not "less")

* "less elements" -> "fewer elements" (countable nouns use "fewer" not "less")

* Missing comma here

* "is comprised of" -> "is composed of"

* "comprised of" -> "composed of"

* "If a function is comprised only of special characters" -> "If a function name comprises only special characters"

* "making them comprised of only" -> "making them composed of only"

* "a RPN" -> "an RPN"

* "on to" -> "onto"

* "tightwalker" -> "tightrope walker"

* "whatever's" -> "whatever is"

* "youre" -> "you're"

* "So let'use throw" -> "So let's throw"

* "Protip:" -> "Pro. tip"

* "The intial stack" -> "The initial stack"

* "whaale" -> "whale" (in alt text)

* "oisters" -> "oysters"

* "mornin" -> "morning"

* "adjecent" -> "adjacent"

* "listOfFuns" -> "listOfFuncs"

* "schtick" -> "shtick"

* "Protip" -> "Pro. tip"

* "sequitor" -> "sequitur"

* "heapload" -> "heap load"

* "sublist" -> "sub list"

* "permision" -> "permission"

* "ekcetera" -> "Et cetera" (though Etc., etc... is probably better)

* "ghc's" -> "GHC's"

* "satifies" -> "satisfies"

* "uninverting" -> "un-inverting"

* "anymore" -> "any more"

* "of any of the previous ones" -> "of any previous ones"

* "voila" -> "voilà"

* "If it it's not" -> "If it's not"

* "manually check the if the laws hold" -> "manually check if the laws hold"

* "object oriented" -> "object-oriented"

* "Tip top!" -> "Tip-top!"

* "It's a sort of a beefed up" -> "It's a sort of beefed up"

* "provides a the" -> "provides a"

* "left node is has" -> "left node has"

* "sort of an interface" -> "sort of interface"

* "run of the mill" -> "run-of-the-mill"

* "also know as unit" -> "also known as "unit""

* "that have a lowest possible" -> "that have the lowest possible"

* "If you're going to try and implement this, you'll probably going to " -> "If you're going to try and implement this, you'll probably need to "

* "anymore" -> "any more"

---------

Co-authored-by: Stanislav (Stanley) Modrak <44023416+smith558@users.noreply.github.com>

Author: chrisdenman

README.md

@@ -35,7 +35,7 @@ Discuss the ideas with the community.
 * Haskell Discourse - https://discourse.haskell.org/t/learn-you-a-haskell-a-community-version/4056
 
 ## Licence
-This domain and repository is in no way affiliated with Miran Lipovača (the original author) and is being extended and modified with his permision as per the licence the original work was released under ([Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-nc-sa/3.0/)) as well as his literal statement encouraging modifications to be made ([FAQ](http://learnyouahaskell.com/faq)).
+This domain and repository is in no way affiliated with Miran Lipovača (the original author) and is being extended and modified with his permission as per the licence the original work was released under ([Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-nc-sa/3.0/)) as well as his literal statement encouraging modifications to be made ([FAQ](http://learnyouahaskell.com/faq)).
 
 ##
 This work is licensed under a [Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-nc-sa/3.0/).

docs/a-fistful-of-monads.html

@@ -724,7 +724,7 @@ <h2>Walk the line</h2>
 wrapped in a <span class="fixed">Just</span>. But when many more birds end up on
 one side of the pole, we get a <span class="fixed">Nothing</span>. This is cool,
 but we seem to have lost the ability to repeatedly land birds on the pole. We
-can't do <span class="fixed">landLeft 1 (landRight 1 (0,0))</span> anymore
+can't do <span class="fixed">landLeft 1 (landRight 1 (0,0))</span> any more
 because when we apply <span class="fixed">landRight 1</span> to <span
 class="fixed">(0,0)</span>, we don't get a <span class="fixed">Pole</span>, but
 a <span class="fixed">Maybe Pole</span>. <span class="fixed">landLeft 1</span>
@@ -861,7 +861,7 @@ <h2>Walk the line</h2>
 
 <p>
 Now we can chain it together with our bird landings. It will always cause our walker
-to fall, because it ignores whatever's passed to it and always returns a
+to fall, because it ignores whatever is passed to it and always returns a
 failure. Check it:
 </p>
 
@@ -1106,7 +1106,7 @@ <h2>do notation</h2>
 expression
 back to a chain of <span class="fixed">&gt;&gt;=</span> applications. Rather,
 its result is the result of the whole glued up monadic value, taking into
-account the possible failure of any of the previous ones.
+account the possible failure of any previous ones.
 </p>
 
 <p>
@@ -1139,10 +1139,10 @@ <h2>do notation</h2>
 </p>
 
 <p>
-Our tightwalker's routine can also be expressed with <span class="fixed">do</span>
+Our tightrope walker's routine can also be expressed with <span class="fixed">do</span>
 notation. <span class="fixed">landLeft</span> and <span class="fixed">landRight</span>
 take a number of birds and a pole and produce a pole wrapped in a <span
-class="fixed">Just</span>, unless the tightwalker
+class="fixed">Just</span>, unless the tightrope walker
 slips, in which case a <span class="fixed">Nothing</span> is produced. We used
 <span class="fixed">&gt;&gt;=</span> to chain successive steps because each one
 relied on the previous one and each one had an added context of possible
@@ -1426,7 +1426,7 @@ <h2>The list monad</h2>
 
 <p>
 The lambda is applied to every element and we get a list of lists. Finally, we
-just flatten the list and voila! We've applied a non-deterministic function to a
+just flatten the list and voilà! We've applied a non-deterministic function to a
 non-deterministic value!
 </p>
 
@@ -1726,7 +1726,7 @@ <h3>A knight's quest</h3>
 horizontally or vertically but its movement has to be both horizontal and
 vertical. <span class="fixed">(c',r')</span> takes on every value from the list
 of movements and then <span class="fixed">guard</span> makes sure that the new
-move, <span class="fixed">(c',r')</span> is still on the board. If it it's not,
+move, <span class="fixed">(c',r')</span> is still on the board. If it's not,
 it produces an empty list, which causes a failure and <span
 class="fixed">return (c',r')</span> isn't carried out for that position.
 </p>
@@ -1861,7 +1861,7 @@ <h2>Monad laws</h2>
 reasonably sure that all is well with the monad laws for that type. We can rely
 on the types that come with the standard library to satisfy the laws, but later
 when we go about making our own monads, we're going to have to manually check
-the if the laws hold. But don't worry, they're not complicated.
+if the laws hold. But don't worry, they're not complicated.
 </p>
 
 <h3>Left identity</h3>

docs/for-a-few-monads-more.html

@@ -853,7 +853,7 @@ <h3>Difference lists</h3>
 </pre>
 
 <p>
-Tip top! Now we can increase the efficiency of our <span
+Tip-top! Now we can increase the efficiency of our <span
 class="fixed">gcdReverse</span> function by making it use difference lists instead of normal
 lists:
 </p>
@@ -975,7 +975,7 @@ <h3>Comparing Performance</h3>
 <a name="reader"></a>
 <h2>Reader? Ugh, not this joke again.</h2>
 
-<img src="assets/images/for-a-few-monads-more/revolver.png" alt="bang youre dead" class="left" width="280"
+<img src="assets/images/for-a-few-monads-more/revolver.png" alt="bang you're dead" class="left" width="280"
 height="106">
 
 <p>
@@ -2154,7 +2154,7 @@ <h3>The join function</h3>
 flattened with <span class="fixed">join</span> and then run, it first puts
 <span class="fixed">2</span> and <span class="fixed">1</span> onto the stack and
 then <span class="fixed">push 10</span> gets carried out, pushing a <span
-class="fixed">10</span> on to the top.
+class="fixed">10</span> onto the top.
 </p>
 
 <p>
@@ -2474,7 +2474,7 @@ <h3>Making a safe RPN calculator</h3>
 height="396">
 
 <p>
-When we were solving the problem of <a href="http://learnyouahaskell.com/reverse-polish-notation-calculator">implementing a RPN calculator</a>,
+When we were solving the problem of <a href="http://learnyouahaskell.com/reverse-polish-notation-calculator">implementing an RPN calculator</a>,
 we noted that it worked fine as long as the input that it got made sense.
 But if something went wrong, it caused our whole program to crash. Now that we
 know how to take some code that we have and make it monadic, let's take our RPN
@@ -2840,7 +2840,7 @@ <h2>Making monads</h2>
 <p>
 The first line is just one quarter. In the second line we add two halves to get
 a whole and in the third line we add one third with five quarters and get
-nineteen twelfths. So let'use throw out our floating points and use
+nineteen twelfths. So let's throw out our floating points and use
 <span class="fixed">Rational</span> for our probabilities:
 </p>