Post-process pandoc output to add chapters class to chapter list

Author: Gregory Cox

markdown/generate.sh

@@ -54,7 +54,10 @@ do
         --metadata title="${title[$i]}$titlesuffix" \
         -V prev_title="$prev_title" -V prev_filename=$prev_filename \
         -V next_title="$next_title" -V next_filename=$next_filename \
-        -o generated_html/${filename[$i]}.html source_md/${filename[$i]}.md   
+        -o generated_html/${filename[$i]}.html source_md/${filename[$i]}.md
+
+   sed '/<p><img/ { N; N; N; s#<p>\(<img[^>]*\) /></p>#\1># }
+       s# />#>#' -i generated_html/${filename[$i]}.html
 done
 
 cat source_md/chapters_foot.md >>$chapterfile
@@ -63,6 +66,11 @@ pandoc -d config/pandoc-defaults.yml --template=config/template.html \
     -V title="Chapters" --metadata title="${title[$i]}$titlesuffix" \
     -o generated_html/chapters.html $chapterfile
 
+sed 's/<ol/<ol class="chapters"/' -i generated_html/chapters.html
+
 pandoc -d config/pandoc-defaults.yml --template=config/template.html \
     -V faq=true -V title="FAQ" --metadata title="${title[$i]}$titlesuffix" \
     -o generated_html/faq.html source_md/faq.md
+
+   sed '/<p><img/ { N; N; N; s#<p>\(<img[^>]*\) /></p>#\1># }
+       s# />#>#' -i generated_html/faq.html

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

@@ -41,8 +41,8 @@ <h1 id="a-fistful-of-monads">A Fistful of Monads</h1>
 <p>In this chapter, we’ll learn about monads, which are just beefed up
 applicative functors, much like applicative functors are only beefed up
 functors.</p>
-<p><img src="assets/images/a-fistful-of-monads/smugpig.png"
-class="right" width="307" height="186" alt="more cool than u" /></p>
+<img src="assets/images/a-fistful-of-monads/smugpig.png"
+class="right" width="307" height="186" alt="more cool than u">
 <p>When we started off with functors, we saw that it’s possible to map
 functions over various data types. We saw that for this purpose, the
 <code>Functor</code> type class was introduced and it had us asking the
@@ -119,8 +119,8 @@ <h1 id="a-fistful-of-monads">A Fistful of Monads</h1>
 that it’s easy as one two three.</p>
 <h2 id="getting-our-feet-wet-with-maybe">Getting our feet wet with
 Maybe</h2>
-<p><img src="assets/images/a-fistful-of-monads/buddha.png" class="left"
-width="302" height="387" alt="monads, grasshoppa" /></p>
+<img src="assets/images/a-fistful-of-monads/buddha.png" class="left"
+width="302" height="387" alt="monads, grasshoppa">
 <p>Now that we have a vague idea of what monads are about, let’s see if
 we can make that idea a bit less vague.</p>
 <p>Much to no one’s surprise, <code>Maybe</code> is a monad, so let’s
@@ -264,8 +264,8 @@ <h2 id="the-monad-type-class">The Monad type class</h2>
 
     fail :: String -&gt; m a
     fail msg = error msg</code></pre>
-<p><img src="assets/images/a-fistful-of-monads/kid.png" class="right"
-width="363" height="451" alt="this is you on monads" /></p>
+<img src="assets/images/a-fistful-of-monads/kid.png" class="right"
+width="363" height="451" alt="this is you on monads">
 <p>Let’s start with the first line. It says
 <code>class Monad m where</code>. But wait, didn’t we say that monads
 are just beefed up applicative functors? Shouldn’t there be a class
@@ -294,8 +294,8 @@ <h2 id="the-monad-type-class">The Monad type class</h2>
 function execution or anything, it just takes a normal value and puts it
 in a context.</p>
 </div>
-<p><img src="assets/images/a-fistful-of-monads/tur2.png" class="left"
-width="169" height="145" alt="hmmm yaes" /></p>
+<img src="assets/images/a-fistful-of-monads/tur2.png" class="left"
+width="169" height="145" alt="hmmm yaes">
 <p>The next function is <code>&gt;&gt;=</code>, or bind. It’s like
 function application, only instead of taking a normal value and feeding
 it to a normal function, it takes a monadic value (that is, a value with
@@ -348,8 +348,8 @@ <h2 id="the-monad-type-class">The Monad type class</h2>
 result of using <code>&gt;&gt;=</code> will be <code>Nothing</code> as
 well.</p>
 <h2 id="walk-the-line">Walk the line</h2>
-<p><img src="assets/images/a-fistful-of-monads/pierre.png" class="left"
-width="374" height="405" alt="pierre" /></p>
+<img src="assets/images/a-fistful-of-monads/pierre.png" class="left"
+width="374" height="405" alt="pierre">
 <p>Now that we know how to feed a <code>Maybe a</code> value to a
 function of type <code>a -&gt; Maybe b</code> while taking into account
 the context of possible failure, let’s see how we can use
@@ -518,8 +518,8 @@ <h2 id="walk-the-line">Walk the line</h2>
 (<code>&gt;&gt;=</code>) instead of normal application:</p>
 <pre class="haskell:hs"><code>ghci&gt; return (0,0) &gt;&gt;= landLeft 1 &gt;&gt;= landRight 4 &gt;&gt;= landLeft (-1) &gt;&gt;= landRight (-2)
 Nothing</code></pre>
-<p><img src="assets/images/a-fistful-of-monads/banana.png" class="right"
-width="262" height="130" alt="iama banana" /></p>
+<img src="assets/images/a-fistful-of-monads/banana.png" class="right"
+width="262" height="130" alt="iama banana">
 <p>Awesome. The final result represents failure, which is what we
 expected. Let’s see how this result was obtained. First,
 <code>return</code> puts <code>(0,0)</code> into a default context,
@@ -600,8 +600,8 @@ <h2 id="walk-the-line">Walk the line</h2>
         Just pole2 -&gt; case landLeft 2 pole2 of
             Nothing -&gt; Nothing
             Just pole3 -&gt; landLeft 1 pole3</code></pre>
-<p><img src="assets/images/a-fistful-of-monads/centaur.png"
-class="right" width="297" height="331" alt="john joe glanton" /></p>
+<img src="assets/images/a-fistful-of-monads/centaur.png"
+class="right" width="297" height="331" alt="john joe glanton">
 <p>We land a bird on the left and then we examine the possibility of
 failure and the possibility of success. In the case of failure, we
 return a <code>Nothing</code>. In the case of success, we land birds on
@@ -684,8 +684,8 @@ <h2 id="do-notation">do notation</h2>
     x &lt;- Just 3
     y &lt;- Just &quot;!&quot;
     Just (show x ++ y)</code></pre>
-<p><img src="assets/images/a-fistful-of-monads/owld.png" class="right"
-width="269" height="348" alt="90s owl" /></p>
+<img src="assets/images/a-fistful-of-monads/owld.png" class="right"
+width="269" height="348" alt="90s owl">
 <p>It would seem as though we’ve gained the ability to temporarily
 extract things from <code>Maybe</code> values without having to check if
 the <code>Maybe</code> values are <code>Just</code> values or
@@ -841,8 +841,8 @@ <h2 id="do-notation">do notation</h2>
 of our monad instead of causing a program-wide failure, which is pretty
 neat.</p>
 <h2 id="the-list-monad">The list monad</h2>
-<p><img src="assets/images/a-fistful-of-monads/deadcat.png" class="left"
-width="235" height="230" alt="dead cat" /></p>
+<img src="assets/images/a-fistful-of-monads/deadcat.png" class="left"
+width="235" height="230" alt="dead cat">
 <p>So far, we’ve seen how <code>Maybe</code> values can be viewed as
 values with a failure context and how we can incorporate failure
 handling into our code by using <code>&gt;&gt;=</code> to feed them to
@@ -925,8 +925,8 @@ <h2 id="the-list-monad">The list monad</h2>
 with <code>&gt;&gt;=</code>, propagating the non-determinism:</p>
 <pre class="haskell:hs"><code>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;)]</code></pre>
-<p><img src="assets/images/a-fistful-of-monads/concatmap.png"
-class="left" width="399" height="340" alt="concatmap" /></p>
+<img src="assets/images/a-fistful-of-monads/concatmap.png"
+class="left" width="399" height="340" alt="concatmap">
 <p>The list <code>[1,2]</code> gets bound to <code>n</code> and
 <code>['a','b']</code> gets bound to <code>ch</code>. Then, we do
 <code>return (n,ch)</code> (or <code>[(n,ch)]</code>), which means
@@ -1061,8 +1061,8 @@ <h3 id="a-knights-quest">A knight’s quest</h3>
 three moves. We’ll just use a pair of numbers to represent the knight’s
 position on the chess board. The first number will determine the column
 he’s in and the second number will determine the row.</p>
-<p><img src="assets/images/a-fistful-of-monads/chess.png" class="center"
-width="760" height="447" alt="hee haw im a horse" /></p>
+<img src="assets/images/a-fistful-of-monads/chess.png" class="center"
+width="760" height="447" alt="hee haw im a horse">
 <p>Let’s make a type synonym for the knight’s current position on the
 chess board:</p>
 <pre class="haskell:hs"><code>type KnightPos = (Int,Int)</code></pre>
@@ -1144,9 +1144,9 @@ <h3 id="a-knights-quest">A knight’s quest</h3>
 the number of moves to take instead of that number being hardcoded like
 it is now.</p>
 <h2 id="monad-laws">Monad laws</h2>
-<p><img src="assets/images/a-fistful-of-monads/judgedog.png"
+<img src="assets/images/a-fistful-of-monads/judgedog.png"
 class="right" width="343" height="170"
-alt="the court finds you guilty of peeing all over everything" /></p>
+alt="the court finds you guilty of peeing all over everything">
 <p>Just like applicative functors, and functors before them, monads come
 with a few laws that all monad instances must abide by. Just because
 something is made an instance of the <code>Monad</code> type class

markdown/generated_html/chapters.html

@@ -18,7 +18,7 @@
     <div id="content">
 <h1 id="learn-you-a-haskell-for-great-good">Learn You a Haskell for
 Great Good!</h1>
-<ol type="1">
+<ol class="chapters" type="1">
 <li><a href="introduction.html">Introduction</a>
 <ul>
 <li><a href="introduction.html#about-this-tutorial">About this

markdown/generated_html/faq.html

@@ -17,8 +17,8 @@
 <div class="bgwrapper">
     <div id="content">
 <h1 id="faq">FAQ</h1>
-<p><img src="assets/images/faq/turtle.png" class="right" width="349"
-height="204" alt="turtle???" /></p>
+<img src="assets/images/faq/turtle.png" class="right" width="349"
+height="204" alt="turtle???">
 <h2 id="can-i-put-this-tutorial-on-my-site-or-change-it-or-whatever">Can
 I put this tutorial on my site or change it or whatever?</h2>
 <p>Sure, it’s licensed under a <a

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

@@ -32,9 +32,9 @@
                 </ul>
             </div>
 <h1 id="for-a-few-monads-more">For a Few Monads More</h1>
-<p><img src="assets/images/for-a-few-monads-more/clint.png"
+<img src="assets/images/for-a-few-monads-more/clint.png"
 class="right" width="189" height="400"
-alt="there are two kinds of people in the world, my friend. those who learn them a haskell and those who have the job of coding java" /></p>
+alt="there are two kinds of people in the world, my friend. those who learn them a haskell and those who have the job of coding java">
 <p>We’ve seen how monads can be used to take values with contexts and
 apply them to functions and how using <code>&gt;&gt;=</code> or
 <code>do</code> notation allows us to focus on the values themselves
@@ -86,9 +86,9 @@ <h2 id="writer">Writer? I hardly know her!</h2>
 (False,&quot;Compared gang size to 9.&quot;)
 ghci&gt; isBigGang 30
 (True,&quot;Compared gang size to 9.&quot;)</code></pre>
-<p><img src="assets/images/for-a-few-monads-more/tuco.png" class="left"
+<img src="assets/images/for-a-few-monads-more/tuco.png" class="left"
 width="196" height="280"
-alt="when you have to poop, poop, don’t talk" /></p>
+alt="when you have to poop, poop, don’t talk">
 <p>So far so good. <code>isBigGang</code> takes a normal value and
 returns a value with a context. As we’ve just seen, feeding it a normal
 value is not a problem. Now what if we already have a value that has a
@@ -255,9 +255,9 @@ <h3 id="the-writer-type">The Writer type</h3>
 <pre class="haskell:hs"><code>instance (Monoid w) =&gt; Monad (Writer w) where
     return x = Writer (x, mempty)
     (Writer (x,v)) &gt;&gt;= f = let (Writer (y, v&#39;)) = f x in Writer (y, v `mappend` v&#39;)</code></pre>
-<p><img src="assets/images/for-a-few-monads-more/angeleyes.png"
+<img src="assets/images/for-a-few-monads-more/angeleyes.png"
 class="right" width="383" height="248"
-alt="when you have to poop, poop, don’t talk" /></p>
+alt="when you have to poop, poop, don’t talk">
 <p>First off, let’s examine <code>&gt;&gt;=</code>. Its implementation
 is essentially the same as <code>applyLog</code>, only now that our
 tuple is wrapped in the <code>Writer</code> <code>newtype</code>, we
@@ -492,8 +492,8 @@ <h3 id="inefficient-list-construction">Inefficient list
 <p>It’s inefficient because it ends up associating the use of
 <code>++</code> to the left instead of to the right.</p>
 <h3 id="difference-lists">Difference lists</h3>
-<p><img src="assets/images/for-a-few-monads-more/cactus.png"
-class="left" width="147" height="300" alt="cactuses" /></p>
+<img src="assets/images/for-a-few-monads-more/cactus.png"
+class="left" width="147" height="300" alt="cactuses">
 <p>Because lists can sometimes be inefficient when repeatedly appended
 in this manner, it’s best to use a data structure that always supports
 efficient appending. One such data structure is the difference list. A
@@ -617,8 +617,8 @@ <h3 id="comparing-performance">Comparing Performance</h3>
 <p>Oh, by the way, the song Final Countdown by Europe is now stuck in
 your head. Enjoy!</p>
 <h2 id="reader">Reader? Ugh, not this joke again.</h2>
-<p><img src="assets/images/for-a-few-monads-more/revolver.png"
-class="left" width="280" height="106" alt="bang youre dead" /></p>
+<img src="assets/images/for-a-few-monads-more/revolver.png"
+class="left" width="280" height="106" alt="bang youre dead">
 <p>In the <a
 href="functors-applicative-functors-and-monoids.html">chapter about
 applicatives</a>, we saw that the function type, <code>(-&gt;) r</code>
@@ -725,8 +725,8 @@ <h2 id="reader">Reader? Ugh, not this joke again.</h2>
 results and the <code>&gt;&gt;=</code> implementation will make sure
 that it all works out.</p>
 <h2 id="state">Tasteful stateful computations</h2>
-<p><img src="assets/images/for-a-few-monads-more/texas.png" class="left"
-width="244" height="230" alt="don’t jest with texas" /></p>
+<img src="assets/images/for-a-few-monads-more/texas.png" class="left"
+width="244" height="230" alt="don’t jest with texas">
 <p>Haskell is a pure language and because of that, our programs are made
 of functions that can’t change any global state or variables, they can
 only do some computations and return them results. This restriction
@@ -876,8 +876,8 @@ <h3 id="the-state-monad">The State monad</h3>
 because <code>return</code> has to put a value in a minimal context. So
 <code>return</code> will make a stateful computation that presents a
 certain value as the result and keeps the state unchanged.</p>
-<p><img src="assets/images/for-a-few-monads-more/badge.png"
-class="right" width="182" height="160" alt="im a cop" /></p>
+<img src="assets/images/for-a-few-monads-more/badge.png"
+class="right" width="182" height="160" alt="im a cop">
 <p>What about <code>&gt;&gt;=</code>? Well, the result of feeding a
 stateful computation to a function with <code>&gt;&gt;=</code> has to be
 a stateful computation, right? So we start off with the
@@ -1146,8 +1146,8 @@ <h2 id="useful-monadic-functions">Some useful monadic functions</h2>
 counterparts of functions that we already know, like <code>filter</code>
 and <code>foldl</code>. Let’s see what they are then!</p>
 <h3 id="liftm-and-friends">liftM and friends</h3>
-<p><img src="assets/images/for-a-few-monads-more/wolf.png" class="right"
-width="394" height="222" alt="im a cop too" /></p>
+<img src="assets/images/for-a-few-monads-more/wolf.png" class="right"
+width="394" height="222" alt="im a cop too">
 <p>When we started our journey to the top of Monad Mountain, we first
 looked at functors, which are for things that can be mapped over. Then,
 we learned about improved functors called applicative functors, which
@@ -1363,8 +1363,8 @@ <h3 id="the-join-function">The join function</h3>
 joinedMaybes = do
     m &lt;- Just (Just 8)
     m</code></pre>
-<p><img src="assets/images/for-a-few-monads-more/tipi.png" class="right"
-width="253" height="379" alt="im a cop too as well also" /></p>
+<img src="assets/images/for-a-few-monads-more/tipi.png" class="right"
+width="253" height="379" alt="im a cop too as well also">
 <p>Perhaps the most interesting thing about <code>join</code> is that
 for every monad, feeding a monadic value to a function with
 <code>&gt;&gt;=</code> is the same thing as just mapping that function
@@ -1532,8 +1532,8 @@ <h3 id="foldm">foldM</h3>
 is cool as well because then you log whatever you want as your fold goes
 along its way.</p>
 <h3 id="making-a-safe-rpn-calculator">Making a safe RPN calculator</h3>
-<p><img src="assets/images/for-a-few-monads-more/miner.png" class="left"
-width="280" height="396" alt="i’ve found yellow!" /></p>
+<img src="assets/images/for-a-few-monads-more/miner.png" class="left"
+width="280" height="396" alt="i’ve found yellow!">
 <p>When we were solving the problem of <a
 href="http://learnyouahaskell.com/reverse-polish-notation-calculator">implementing
 a RPN calculator</a>, we noted that it worked fine as long as the input
@@ -1717,8 +1717,8 @@ <h3 id="composing-monadic-functions">Composing monadic functions</h3>
 <pre class="haskell:hs"><code>canReachIn :: Int -&gt; KnightPos -&gt; KnightPos -&gt; Bool
 canReachIn x start end = end `elem` inMany x start</code></pre>
 <h2 id="making-monads">Making monads</h2>
-<p><img src="assets/images/for-a-few-monads-more/spearhead.png"
-class="center" width="780" height="244" alt="kewl" /></p>
+<img src="assets/images/for-a-few-monads-more/spearhead.png"
+class="center" width="780" height="244" alt="kewl">
 <p>In this section, we’re going to look at an example of how a type gets
 made, identified as a monad and then given the appropriate
 <code>Monad</code> instance. We don’t usually set out to make a monad
@@ -1817,8 +1817,8 @@ <h2 id="making-monads">Making monads</h2>
 happen. <code>'c'</code> and <code>'d'</code> are also equally likely to
 happen. Here’s a picture of a probability list that models this
 scenario:</p>
-<p><img src="assets/images/for-a-few-monads-more/prob.png" class="left"
-width="456" height="142" alt="probs" /></p>
+<img src="assets/images/for-a-few-monads-more/prob.png" class="left"
+width="456" height="142" alt="probs">
 <p>What are the chances for each of these letters to occur? If we were
 to draw this as just four boxes, each with a probability, what would
 those probabilities be? To find out, all we have to do is multiply each
@@ -1856,8 +1856,8 @@ <h2 id="making-monads">Making monads</h2>
     return x = Prob [(x,1%1)]
     m &gt;&gt;= f = flatten (fmap f m)
     fail _ = Prob []</code></pre>
-<p><img src="assets/images/for-a-few-monads-more/ride.png" class="right"
-width="177" height="406" alt="ride em cowboy" /></p>
+<img src="assets/images/for-a-few-monads-more/ride.png" class="right"
+width="177" height="406" alt="ride em cowboy">
 <p>Because we already did all the hard work, the instance is very
 simple. We also defined the <code>fail</code> function, which is the
 same as it is for lists, so if there’s a pattern match failure in a