Replace raw characters with entities (e.g. <) in code blocks

Author: Gregory Cox

docs/functors-applicative-functors-and-monoids.html

@@ -576,7 +576,7 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [(+1),(*100),(*5)] <*> [1,2,3]
+ghci&gt; [(+1),(*100),(*5)] &lt;*&gt; [1,2,3]
 [2,3,4,100,200,300,5,10,15]
 </pre>
 
@@ -598,7 +598,7 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; getZipList $ ZipList [(+1),(*100),(*5)] <*> ZipList [1,2,3]
+ghci&gt; getZipList $ ZipList [(+1),(*100),(*5)] &lt;*&gt; ZipList [1,2,3]
 [2,200,15]
 </pre>
 
@@ -1501,7 +1501,7 @@ <h3><span class="fixed">Any</span> and <span class="fixed">All</span></h3>
 
 <p>
 The other way for <span class="fixed">Bool</span> to be an instance of
-<span class="fixed">Monoid</span> is to kind of do the opposite: have <span class="fixed">&&</span>
+<span class="fixed">Monoid</span> is to kind of do the opposite: have <span class="fixed">&amp;&amp;</span>
 be the binary function and then make <span class="fixed">True</span>
 the identity value. Logical <i>and</i> will return <span class="fixed">True</span> only
 if both of its parameters are <span class="fixed">True</span>. This is the <i>newtype</i>
@@ -1520,7 +1520,7 @@ <h3><span class="fixed">Any</span> and <span class="fixed">All</span></h3>
 <pre name="code" class="haskell:hs">
 instance Monoid All where
         mempty = All True
-        All x `mappend` All y = All (x && y)
+        All x `mappend` All y = All (x &amp;&amp; y)
 </pre>
 
 <p>

docs/making-our-own-types-and-typeclasses.html

@@ -95,7 +95,7 @@ <h1>Making Our Own Types and Typeclasses</h1>
 </pre>
 <p>Notice that when defining a point, we used the same name for the data type and the value constructor. This has no special meaning, although it’s common to use the same name as the type if there’s only one value constructor. So now the <span class="fixed">Circle</span> has two fields, one is of type <span class="fixed">Point</span> and the other of type <span class="fixed">Float</span>. This makes it easier to understand what’s what. Same goes for the rectangle. We have to adjust our <span class="fixed">surface</span> function to reflect these changes.</p>
 <pre name="code" class="haskell:hs">
-surface :: Shape -> Float
+surface :: Shape -&gt; Float
 surface (Circle _ r) = pi * r ^ 2
 surface (Rectangle (Point x1 y1) (Point x2 y2)) = (abs $ x2 - x1) * (abs $ y2 - y1)
 </pre>
@@ -421,7 +421,7 @@ <h1>Making Our Own Types and Typeclasses</h1>
 ghci&gt; Just 100 &gt; Just 50
 True
 </pre>
-<p>But we can’t do something like <span class="fixed">Just (*3) > Just (*2)</span>, because <span class="fixed">(*3)</span> and <span class="fixed">(*2)</span> are functions, which aren’t instances of <span class="fixed">Ord</span>.</p>
+<p>But we can’t do something like <span class="fixed">Just (*3) &gt; Just (*2)</span>, because <span class="fixed">(*3)</span> and <span class="fixed">(*2)</span> are functions, which aren’t instances of <span class="fixed">Ord</span>.</p>
 <p>We can easily use algebraic data types to make enumerations and the <span class="fixed">Enum</span> and <span class="fixed">Bounded</span> typeclasses help us with that. Consider the following data type:</p>
 <pre name="code" class="haskell:hs">
 data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
@@ -681,7 +681,7 @@ <h1>Making Our Own Types and Typeclasses</h1>
 treeElem x EmptyTree = False
 treeElem x (Node a left right)
     | x == a = True
-    | x < a  = treeElem x left
+    | x &lt; a  = treeElem x left
     | x &gt; a  = treeElem x right
 </pre>
 <p>All we had to do was write up the previous paragraph in code. Let’s have some fun with our trees! Instead of manually building one (although we could), we’ll use a fold to build up a tree from a list. Remember, pretty much everything that traverses a list one by one and then returns some sort of value can be implemented with a fold! We’re going to start with the empty tree and then approach a list from the right and just insert element after element into our accumulator tree. </p>

docs/modules.html

@@ -168,21 +168,21 @@ <h1>Modules</h1>
 </pre>
 <p>Say we wanted to know the sum of all third powers that are under 10,000. We can’t map <span class="fixed">(^3)</span> to <span class="fixed">[1..]</span>, apply a filter and then try to sum that up because filtering an infinite list never finishes. You may know that all the elements here are ascending but Haskell doesn’t. That’s why we can do this:</p>
 <pre name="code" class="haskell:ghci">
-ghci&gt; sum $ takeWhile (<10000) $ map (^3) [1..]
+ghci&gt; sum $ takeWhile (&lt;10000) $ map (^3) [1..]
 53361
 </pre>
 <p>We apply <span class="fixed">(^3)</span> to an infinite list and then once an element that’s over 10,000 is encountered, the list is cut off. Now we can sum it up easily.</p>
 <p><span class="label function">dropWhile</span> is similar, only it drops all the elements while the predicate is true. Once predicate equates to <span class="fixed">False</span>, it returns the rest of the list. An extremely useful and lovely function!</p>
 <pre name="code" class="haskell:ghci">
 ghci&gt; dropWhile (/=&#39; &#39;) &quot;This is a sentence&quot;
 &quot; is a sentence&quot;
-ghci&gt; dropWhile (<3) [1,2,2,2,3,4,5,4,3,2,1]
+ghci&gt; dropWhile (&lt;3) [1,2,2,2,3,4,5,4,3,2,1]
 [3,4,5,4,3,2,1]
 </pre>
 <p>We’re given a list that represents the value of a stock by date. The list is made of tuples whose first component is the stock value, the second is the year, the third is the month and the fourth is the date. We want to know when the stock value first exceeded one thousand dollars!</p>
 <pre name="code" class="haskell:ghci">
 ghci&gt; let stock = [(994.4,2008,9,1),(995.2,2008,9,2),(999.2,2008,9,3),(1001.4,2008,9,4),(998.3,2008,9,5)]
-ghci&gt; head (dropWhile (\(val,y,m,d) -&gt; val < 1000) stock)
+ghci&gt; head (dropWhile (\(val,y,m,d) -&gt; val &lt; 1000) stock)
 (1001.4,2008,9,4)
 </pre>
 <p><span class="label function">span</span> is kind of like <span class="fixed">takeWhile</span>, only it returns a pair of lists. The first list contains everything the resulting list from <span class="fixed">takeWhile</span> would contain if it were called with the same predicate and the same list. The second list contains the part of the list that would have been dropped.</p>

docs/recursion.html

@@ -66,7 +66,7 @@ <h1 style="margin-left:-2px">Recursion</h1>
 <pre name="code" class="haskell:hs">
 replicate&#39; :: (Num i, Ord i) =&gt; i -&gt; a -&gt; [a]
 replicate&#39; n x
-    | n <= 0    = []
+    | n &lt;= 0    = []
     | otherwise = x:replicate&#39; (n-1) x
 </pre>
 <p>We used guards here instead of patterns because we’re testing for a boolean condition. If <span class="fixed">n</span> is less than or equal to 0, return an empty list. Otherwise return a list that has <span class="fixed">x</span> as the first element and then <span class="fixed">x</span> replicated n-1 times as the tail. Eventually, the <span class="fixed">(n-1)</span> part will cause our function to reach the edge condition.</p>

docs/starting-out.html

@@ -415,13 +415,13 @@ <h1 style="margin-left:-3px">Starting Out</h1>
 </p>
 <p>If we wanted to write that in Haskell, we could do something like <span class="fixed">take 10 [2,4..]</span>. But what if we didn’t want doubles of the first 10 natural numbers but some kind of more complex function applied on them? We could use a list comprehension for that. List comprehensions are very similar to set comprehensions. We’ll stick to getting the first 10 even numbers for now. The list comprehension we could use is <span class="fixed">[x*2 | x &lt;- [1..10]]</span>. <span class="fixed">x</span> is drawn from <span class="fixed">[1..10]</span> and for every element in <span class="fixed">[1..10]</span> (which we have bound to <span class="fixed">x</span>), we get that element, only doubled. Here’s that comprehension in action. </p>
 <pre name="code" class="haskell: ghci">
-ghci&gt; [x*2 | x <- [1..10]]
+ghci&gt; [x*2 | x &lt;- [1..10]]
 [2,4,6,8,10,12,14,16,18,20]
 </pre>
 <p>As you can see, we get the desired results. Now let’s add a condition (or a predicate) to that comprehension. Predicates go after the binding parts and are separated from them by a comma. Let’s say we want only the elements which, doubled, are greater than or equal to 12.
 </p>
 <pre name="code" class="haskell: ghci">
-ghci&gt; [x*2 | x <- [1..10], x*2 >= 12]
+ghci&gt; [x*2 | x &lt;- [1..10], x*2 &gt;= 12]
 [12,14,16,18,20]
 </pre>
 <p>Cool, it works. How about if we wanted all numbers from 50 to 100 whose remainder when divided with the number 7 is 3? Easy.</p>

docs/syntax-in-functions.html

@@ -106,7 +106,7 @@ <h1 style="margin-left:-3px">Syntax in Functions</h1>
 <p>Which reminds me, you can also pattern match in list comprehensions. Check this out:</p>
 <pre name="code" class="haskell: ghci">
 ghci&gt; let xs = [(1,3), (4,3), (2,4), (5,3), (5,6), (3,1)]
-ghci&gt; [a+b | (a,b) <- xs]
+ghci&gt; [a+b | (a,b) &lt;- xs]
 [4,7,6,8,11,4] </pre>
 <p>
 Should a pattern match fail, it will just move on to the next element.