Replace single quotes with &learnyouahaskell#39; in code blocks

Author: Gregory Cox

docs/a-fistful-of-monads.html

@@ -1461,8 +1461,8 @@ <h2>The list monad</h2>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [1,2] &gt;&gt;= \n -&gt; ['a','b'] &gt;&gt;= \ch -&gt; return (n,ch)
-[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
+ghci&gt; [1,2] &gt;&gt;= \n -&gt; [&#39;a&#39;,&#39;b&#39;] &gt;&gt;= \ch -&gt; return (n,ch)
+[(1,&#39;a&#39;),(1,&#39;b&#39;),(2,&#39;a&#39;),(2,&#39;b&#39;)]
 </pre>
 
 <img src="assets/images/a-fistful-of-monads/concatmap.png" alt="concatmap" class="left" width="399" height="340">
@@ -1502,7 +1502,7 @@ <h2>The list monad</h2>
 listOfTuples :: [(Int,Char)]
 listOfTuples = do
     n &lt;- [1,2]
-    ch &lt;- ['a','b']
+    ch &lt;- [&#39;a&#39;,&#39;b&#39;]
     return (n,ch)
 </pre>
 
@@ -1522,8 +1522,8 @@ <h2>The list monad</h2>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [ (n,ch) | n &lt;- [1,2], ch &lt;- ['a','b'] ]
-[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
+ghci&gt; [ (n,ch) | n &lt;- [1,2], ch &lt;- [&#39;a&#39;,&#39;b&#39;] ]
+[(1,&#39;a&#39;),(1,&#39;b&#39;),(2,&#39;a&#39;),(2,&#39;b&#39;)]
 </pre>
 
 <p>
@@ -1553,7 +1553,7 @@ <h2>The list monad</h2>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [ x | x &lt;- [1..50], '7' `elem` show x ]
+ghci&gt; [ x | x &lt;- [1..50], &#39;7&#39; `elem` show x ]
 [7,17,27,37,47]
 </pre>
 
@@ -1623,7 +1623,7 @@ <h2>The list monad</h2>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [1..50] &gt;&gt;= (\x -&gt; guard ('7' `elem` show x) &gt;&gt; return x)
+ghci&gt; [1..50] &gt;&gt;= (\x -&gt; guard (&#39;7&#39; `elem` show x) &gt;&gt; return x)
 [7,17,27,37,47]
 </pre>
 
@@ -1662,7 +1662,7 @@ <h2>The list monad</h2>
 sevensOnly :: [Int]
 sevensOnly = do
     x &lt;- [1..50]
-    guard ('7' `elem` show x)
+    guard (&#39;7&#39; `elem` show x)
     return x
 </pre>
 
@@ -1673,7 +1673,7 @@ <h2>The list monad</h2>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; [ x | x &lt;- [1..50], '7' `elem` show x ]
+ghci&gt; [ x | x &lt;- [1..50], &#39;7&#39; `elem` show x ]
 [7,17,27,37,47]
 </pre>
 
@@ -1714,11 +1714,11 @@ <h3>A knight’s quest</h3>
 <pre name="code" class="haskell:hs">
 moveKnight :: KnightPos -&gt; [KnightPos]
 moveKnight (c,r) = do
-    (c',r') &lt;- [(c+2,r-1),(c+2,r+1),(c-2,r-1),(c-2,r+1)
+    (c&#39;,r&#39;) &lt;- [(c+2,r-1),(c+2,r+1),(c-2,r-1),(c-2,r+1)
                ,(c+1,r-2),(c+1,r+2),(c-1,r-2),(c-1,r+2)
                ]
-    guard (c' `elem` [1..8] &amp;&amp; r' `elem` [1..8])
-    return (c',r')
+    guard (c&#39; `elem` [1..8] &amp;&amp; r&#39; `elem` [1..8])
+    return (c&#39;,r&#39;)
 </pre>
 
 <p>

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

@@ -389,7 +389,7 @@ <h3>The Writer type</h3>
 <pre name="code" class="haskell:hs">
 instance (Monoid w) =&gt; Monad (Writer w) where
     return x = Writer (x, mempty)
-    (Writer (x,v)) &gt;&gt;= f = let (Writer (y, v')) = f x in Writer (y, v `mappend` v')
+    (Writer (x,v)) &gt;&gt;= f = let (Writer (y, v&#39;)) = f x in Writer (y, v `mappend` v&#39;)
 </pre>
 
 
@@ -551,10 +551,10 @@ <h3>Adding logging to programs</h3>
 
 
 <pre name="code" class="haskell:hs">
-gcd' :: Int -&gt; Int -&gt; Int
-gcd' a b
+gcd&#39; :: Int -&gt; Int -&gt; Int
+gcd&#39; a b
     | b == 0    = a
-    | otherwise = gcd' b (a `mod` b)
+    | otherwise = gcd&#39; b (a `mod` b)
 </pre>
 
 <p>
@@ -572,7 +572,7 @@ <h3>Adding logging to programs</h3>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; gcd' 8 3
+ghci&gt; gcd&#39; 8 3
 1
 </pre>
 
@@ -584,7 +584,7 @@ <h3>Adding logging to programs</h3>
 </p>
 
 <pre name="code" class="haskell:hs">
-gcd' :: Int -&gt; Int -&gt; Writer [String] Int
+gcd&#39; :: Int -&gt; Int -&gt; Writer [String] Int
 </pre>
 
 <p>
@@ -594,14 +594,14 @@ <h3>Adding logging to programs</h3>
 <pre name="code" class="haskell:hs">
 import Control.Monad.Writer
 
-gcd' :: Int -&gt; Int -&gt; Writer [String] Int
-gcd' a b
+gcd&#39; :: Int -&gt; Int -&gt; Writer [String] Int
+gcd&#39; a b
     | b == 0 = do
         tell ["Finished with " ++ show a]
         return a
     | otherwise = do
         tell [show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b)]
-        gcd' b (a `mod` b)
+        gcd&#39; b (a `mod` b)
 </pre>
 
 <p>
@@ -648,7 +648,7 @@ <h3>Adding logging to programs</h3>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; fst $ runWriter (gcd' 8 3)
+ghci&gt; fst $ runWriter (gcd&#39; 8 3)
 1
 </pre>
 
@@ -658,7 +658,7 @@ <h3>Adding logging to programs</h3>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; mapM_ putStrLn $ snd $ runWriter (gcd' 8 3)
+ghci&gt; mapM_ putStrLn $ snd $ runWriter (gcd&#39; 8 3)
 8 mod 3 = 2
 3 mod 2 = 1
 2 mod 1 = 0
@@ -861,13 +861,13 @@ <h3>Difference lists</h3>
 <pre name="code" class="haskell:hs">
 import Control.Monad.Writer
 
-gcd' :: Int -&gt; Int -&gt; Writer (DiffList String) Int
-gcd' a b
+gcd&#39; :: Int -&gt; Int -&gt; Writer (DiffList String) Int
+gcd&#39; a b
     | b == 0 = do
         tell (toDiffList ["Finished with " ++ show a])
         return a
     | otherwise = do
-        result &lt;- gcd' b (a `mod` b)
+        result &lt;- gcd&#39; b (a `mod` b)
         tell (toDiffList [show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b)])
         return result
 </pre>
@@ -1162,8 +1162,8 @@ <h2>Tasteful stateful computations</h2>
 threeCoins :: StdGen -&gt; (Bool, Bool, Bool)
 threeCoins gen =
     let (firstCoin, newGen) = random gen
-        (secondCoin, newGen') = random newGen
-        (thirdCoin, newGen'') = random newGen'
+        (secondCoin, newGen&#39;) = random newGen
+        (thirdCoin, newGen&#39;&#39;) = random newGen&#39;
     in  (firstCoin, secondCoin, thirdCoin)
 </pre>
 
@@ -1769,9 +1769,9 @@ <h2>Error error on the wall</h2>
 ghci&gt; Right 3 &gt;&gt;= \x -&gt; return (x + 100)
 
 &lt;interactive&gt;:1:0:
-    Ambiguous type variable `a' in the constraints:
-      `Error a' arising from a use of `it' at &lt;interactive&gt;:1:0-33
-      `Show a' arising from a use of `print' at &lt;interactive&gt;:1:0-33
+    Ambiguous type variable `a&#39; in the constraints:
+      `Error a&#39; arising from a use of `it&#39; at &lt;interactive&gt;:1:0-33
+      `Show a&#39; arising from a use of `print&#39; at &lt;interactive&gt;:1:0-33
     Probable fix: add a type signature that fixes these type variable(s)
 </pre>
 
@@ -2946,8 +2946,8 @@ <h2>Making monads</h2>
 <pre name="code" class="haskell:hs">
 thisSituation :: Prob (Prob Char)
 thisSituation = Prob
-    [( Prob [('a',1%2),('b',1%2)] , 1%4 )
-    ,( Prob [('c',1%2),('d',1%2)] , 3%4)
+    [( Prob [(&#39;a&#39;,1%2),(&#39;b&#39;,1%2)] , 1%4 )
+    ,( Prob [(&#39;c&#39;,1%2),(&#39;d&#39;,1%2)] , 3%4)
     ]
 </pre>
 

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

@@ -55,9 +55,9 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 </p><p>We can play around with it to gain some intuition. It’s pretty simple really. Check out this piece of code:</p>
 <pre name="code" class="haskell:hs">
 main = do line &lt;- getLine
-          let line' = reverse line
-          putStrLn $ "You said " ++ line' ++ " backwards!"
-          putStrLn $ "Yes, you really said" ++ line' ++ " backwards!"
+          let line&#39; = reverse line
+          putStrLn $ "You said " ++ line&#39; ++ " backwards!"
+          putStrLn $ "Yes, you really said" ++ line&#39; ++ " backwards!"
 </pre>
 <p>The user is prompted for a line and we give it back to the user, only reversed. Here’s how to rewrite this by using <span class="fixed">fmap</span>:</p>
 <pre name="code" class="haskell:hs">
@@ -74,7 +74,7 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 import Data.Char
 import Data.List
 
-main = do line &lt;- fmap (intersperse '-' . reverse . map toUpper) getLine
+main = do line &lt;- fmap (intersperse &#39;-&#39; . reverse . map toUpper) getLine
           putStrLn line
 </pre>
 <pre name="code" class="plain">
@@ -225,8 +225,8 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 <pre name="code" class="haskell:hs">
 ghci&gt; :t fmap (++) (Just "hey")
 fmap (++) (Just "hey") :: Maybe ([Char] -&gt; [Char])
-ghci&gt; :t fmap compare (Just 'a')
-fmap compare (Just 'a') :: Maybe (Char -&gt; Ordering)
+ghci&gt; :t fmap compare (Just &#39;a&#39;)
+fmap compare (Just &#39;a&#39;) :: Maybe (Char -&gt; Ordering)
 ghci&gt; :t fmap compare "A LIST OF CHARS"
 fmap compare "A LIST OF CHARS" :: [Char -&gt; Ordering]
 ghci&gt; :t fmap (\x y z -&gt; x + y / z) [3,4,5,6]
@@ -444,7 +444,7 @@ <h1>Functors, Applicative Functors and Monoids</h1>
 ghci&gt; getZipList $ max &lt;$&gt; ZipList [1,2,3,4,5,3] &lt;*&gt; ZipList [5,3,1,2]
 [5,3,3,4]
 ghci&gt; getZipList $ (,,) &lt;$&gt; ZipList "dog" &lt;*&gt; ZipList "cat" &lt;*&gt; ZipList "rat"
-[('d','c','r'),('o','a','a'),('g','t','t')]
+[(&#39;d&#39;,&#39;c&#39;,&#39;r&#39;),(&#39;o&#39;,&#39;a&#39;,&#39;a&#39;),(&#39;g&#39;,&#39;t&#39;,&#39;t&#39;)]
 </pre>
 <div class="hintbox">The <span class="fixed">(,,)</span> function is the same as <span class="fixed">\x y z -&gt; (x,y,z)</span>. Also, the <span class="fixed">(,)</span> function is the same as <span class="fixed">\x y -&gt; (x,y)</span>.</div>
 <p>Aside from <span class="fixed">zipWith</span>, the standard library has functions such as <span class="fixed">zipWith3</span>, <span class="fixed">zipWith4</span>, all the way up to 7. <span class="fixed">zipWith</span> takes a function that takes two parameters and zips two lists with it. <span class="fixed">zipWith3</span> takes a function that takes three parameters and zips three lists with it, and so on. By using zip lists with an applicative style, we don’t have to have a separate zip function for each number of lists that we want to zip together. We just use the applicative style to zip together an arbitrary amount of lists with a function, and that’s pretty cool.</p>
@@ -1832,12 +1832,12 @@ <h3><span class="fixed">Maybe</span> the monoid</h3>
 </p>
 
 <pre name="code" class="haskell:hs">
-ghci&gt; getFirst $ First (Just 'a') `mappend` First (Just 'b')
-Just 'a'
-ghci&gt; getFirst $ First Nothing `mappend` First (Just 'b')
-Just 'b'
-ghci&gt; getFirst $ First (Just 'a') `mappend` First Nothing
-Just 'a'
+ghci&gt; getFirst $ First (Just &#39;a&#39;) `mappend` First (Just &#39;b&#39;)
+Just &#39;a&#39;
+ghci&gt; getFirst $ First Nothing `mappend` First (Just &#39;b&#39;)
+Just &#39;b&#39;
+ghci&gt; getFirst $ First (Just &#39;a&#39;) `mappend` First Nothing
+Just &#39;a&#39;
 </pre>
 
 <p>