From 4b8acfb31617f5e38457696bf5ae358f36a90702 Mon Sep 17 00:00:00 2001
From: Joel Kaasinen <joel.kaasinen@metosin.fi>
Date: Wed, 8 Sep 2021 10:37:59 +0300
Subject: [PATCH] regenerate html with pandoc 2.2.1

slight changes to code formatting
---
 part1.html | 3592 +++++++++++++++++----------------
 part2.html | 5572 ++++++++++++++++++++++++++--------------------------
 2 files changed, 4580 insertions(+), 4584 deletions(-)

diff --git a/part1.html b/part1.html
index 40aef6b..d3f6b04 100644
--- a/part1.html
+++ b/part1.html
@@ -14,7 +14,7 @@
   <style type="text/css">
 a.sourceLine { display: inline-block; line-height: 1.25; }
 a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
-a.sourceLine:empty { height: 1.2em; position: absolute; }
+a.sourceLine:empty { height: 1.2em; }
 .sourceCode { overflow: visible; }
 code.sourceCode { white-space: pre; position: relative; }
 div.sourceCode { margin: 1em 0; }
@@ -27,13 +27,11 @@ code.sourceCode { white-space: pre-wrap; }
 a.sourceLine { text-indent: -1em; padding-left: 1em; }
 }
 pre.numberSource a.sourceLine
-  { position: relative; }
-pre.numberSource a.sourceLine:empty
-  { position: absolute; }
+  { position: relative; left: -4em; }
 pre.numberSource a.sourceLine::before
-  { content: attr(data-line-number);
-    position: absolute; left: -5em; text-align: right; vertical-align: baseline;
-    border: none; pointer-events: all;
+  { content: attr(title);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; pointer-events: all; display: inline-block;
     -webkit-touch-callout: none; -webkit-user-select: none;
     -khtml-user-select: none; -moz-user-select: none;
     -ms-user-select: none; user-select: none;
@@ -220,29 +218,29 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 <h3 id="features"><span class="header-section-number">1.3.1</span> Features</h3>
 <p>Here’s a showcase of some of the Haskell’s cool features:</p>
 <p><strong>Higher-order functions</strong> – functions can take functions as arguments:</p>
-<div class="sourceCode" id="cb1"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb1-1" data-line-number="1">map length [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;abcdef&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb1"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb1-1" title="1"><span class="fu">map</span> <span class="fu">length</span> [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;abcdef&quot;</span>]</a></code></pre></div>
 <p>This results in <code>[3,6]</code>.</p>
 <p><strong>Anonymous functions aka lambdas</strong> – you can define single-use helper functions without giving them a name</p>
-<div class="sourceCode" id="cb2"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb2-1" data-line-number="1">filter (\x <span class="ot">-&gt;</span> length x <span class="fu">&gt;</span> <span class="dv">1</span>) [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;ef&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb2"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb2-1" title="1"><span class="fu">filter</span> (\x <span class="ot">-&gt;</span> <span class="fu">length</span> x <span class="fu">&gt;</span> <span class="dv">1</span>) [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;ef&quot;</span>]</a></code></pre></div>
 <p>This results in <code>[&quot;abc&quot;,&quot;ef&quot;]</code>.</p>
 <p><strong>Partial application</strong> – you can define new functions by giving another function only some of the arguments it needs. For example this multiplies all elements in a list by 3:</p>
-<div class="sourceCode" id="cb3"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb3-1" data-line-number="1">map (<span class="fu">*</span><span class="dv">3</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb3"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb3-1" title="1"><span class="fu">map</span> (<span class="fu">*</span><span class="dv">3</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p><strong>Algebraic datatypes</strong> – a syntax for defining datatypes that can contain a number of different cases:</p>
-<div class="sourceCode" id="cb4"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb4-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Shape</span> <span class="fu">=</span> <span class="dt">Point</span> <span class="fu">|</span> <span class="dt">Rectangle</span> <span class="dt">Double</span> <span class="dt">Double</span> <span class="fu">|</span> <span class="dt">Circle</span> <span class="dt">Double</span></a></code></pre></div>
+<div class="sourceCode" id="cb4"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb4-1" title="1"><span class="kw">data</span> <span class="dt">Shape</span> <span class="fu">=</span> <span class="dt">Point</span> <span class="fu">|</span> <span class="dt">Rectangle</span> <span class="dt">Double</span> <span class="dt">Double</span> <span class="fu">|</span> <span class="dt">Circle</span> <span class="dt">Double</span></a></code></pre></div>
 <p>Now the type <code>Shape</code> can have values like <code>Point</code>, <code>Rectangle 3 6</code> and <code>Circle 5</code></p>
 <p><strong>Pattern matching</strong> – defining functions based on cases that correspond to your data definitions:</p>
-<div class="sourceCode" id="cb5"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb5-1" data-line-number="1">area <span class="dt">Point</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb5-2" data-line-number="2">area (<span class="dt">Rectangle</span> width height) <span class="fu">=</span> width <span class="fu">*</span> height</a>
-<a class="sourceLine" id="cb5-3" data-line-number="3">area (<span class="dt">Circle</span> radius) <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> pi <span class="fu">*</span> radius</a></code></pre></div>
+<div class="sourceCode" id="cb5"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb5-1" title="1">area <span class="dt">Point</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb5-2" title="2">area (<span class="dt">Rectangle</span> width height) <span class="fu">=</span> width <span class="fu">*</span> height</a>
+<a class="sourceLine" id="cb5-3" title="3">area (<span class="dt">Circle</span> radius) <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> <span class="fu">pi</span> <span class="fu">*</span> radius</a></code></pre></div>
 <p><strong>Lists</strong> – Unlike many languages, Haskell has a concise built-in syntax for lists. Lists can be built from other lists using <em>list comprehensions</em>. Here’s a snippet that generates names of even length from a set of options for first and last names:</p>
-<div class="sourceCode" id="cb6"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb6-1" data-line-number="1">[whole <span class="fu">|</span> first <span class="ot">&lt;-</span> [<span class="st">&quot;Eva&quot;</span>, <span class="st">&quot;Mike&quot;</span>],</a>
-<a class="sourceLine" id="cb6-2" data-line-number="2">         last <span class="ot">&lt;-</span> [<span class="st">&quot;Smith&quot;</span>, <span class="st">&quot;Wood&quot;</span>, <span class="st">&quot;Odd&quot;</span>],</a>
-<a class="sourceLine" id="cb6-3" data-line-number="3">         <span class="kw">let</span> whole <span class="fu">=</span> first <span class="fu">++</span> last,</a>
-<a class="sourceLine" id="cb6-4" data-line-number="4">         even (length whole)]</a></code></pre></div>
+<div class="sourceCode" id="cb6"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb6-1" title="1">[whole <span class="fu">|</span> first <span class="ot">&lt;-</span> [<span class="st">&quot;Eva&quot;</span>, <span class="st">&quot;Mike&quot;</span>],</a>
+<a class="sourceLine" id="cb6-2" title="2">         <span class="fu">last</span> <span class="ot">&lt;-</span> [<span class="st">&quot;Smith&quot;</span>, <span class="st">&quot;Wood&quot;</span>, <span class="st">&quot;Odd&quot;</span>],</a>
+<a class="sourceLine" id="cb6-3" title="3">         <span class="kw">let</span> whole <span class="fu">=</span> first <span class="fu">++</span> <span class="fu">last</span>,</a>
+<a class="sourceLine" id="cb6-4" title="4">         <span class="fu">even</span> (<span class="fu">length</span> whole)]</a></code></pre></div>
 <p>This results in <code>[&quot;EvaSmith&quot;,&quot;EvaOdd&quot;,&quot;MikeWood&quot;]</code>. Thanks to the laziness of Haskell, we can even create so-called <em>infinite lists</em>:</p>
-<div class="sourceCode" id="cb7"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb7-1" data-line-number="1">primes <span class="fu">=</span> [ n <span class="fu">|</span> n <span class="ot">&lt;-</span> [<span class="dv">2</span><span class="fu">..</span>] , all (\k <span class="ot">-&gt;</span> n <span class="ot">`mod`</span> k <span class="fu">/=</span> <span class="dv">0</span>) [<span class="dv">2</span><span class="fu">..</span>n <span class="ot">`div`</span> <span class="dv">2</span>] ]</a></code></pre></div>
+<div class="sourceCode" id="cb7"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb7-1" title="1">primes <span class="fu">=</span> [ n <span class="fu">|</span> n <span class="ot">&lt;-</span> [<span class="dv">2</span><span class="fu">..</span>] , <span class="fu">all</span> (\k <span class="ot">-&gt;</span> n <span class="ot">`mod`</span> k <span class="fu">/=</span> <span class="dv">0</span>) [<span class="dv">2</span><span class="fu">..</span>n <span class="ot">`div`</span> <span class="dv">2</span>] ]</a></code></pre></div>
 <p>The first ten prime numbers can be then obtained by evaluating</p>
-<div class="sourceCode" id="cb8"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb8-1" data-line-number="1">take <span class="dv">10</span> primes</a></code></pre></div>
+<div class="sourceCode" id="cb8"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb8-1" title="1"><span class="fu">take</span> <span class="dv">10</span> primes</a></code></pre></div>
 <p>This evaluates to <code>[2,3,5,7,11,13,17,19,23,29]</code>.</p>
 <p><strong>Parameterized types</strong> – you can define types that are parameterized by other types. For example <code>[Int]</code> is a list of <code>Int</code>s and <code>[Bool]</code> is a list of booleans. You can define typed functions that work on all kinds of lists, for example <code>reverse</code> has the type <code>[a] -&gt; [a]</code> which means it takes a list containing any type <code>a</code>, and returns a list of the same type.</p>
 <p><strong>Type classes</strong> – another form of polymorphism where you can give a function a different implementation depending on the arguments’ types. For example the <code>Show</code> type class defines the function <code>show</code> that can convert values of various types to strings. The <code>Num</code> type class defines arithmetic operators like <code>+</code> that work on all number types (<code>Int</code>, <code>Double</code>, <code>Complex</code>, …).</p>
@@ -477,122 +475,122 @@ Leaving GHCi.</code></pre>
 <p>Looks a bit weird, right? We’ll get back to this as well.</p>
 <h3 id="note-about-misleading-types"><span class="header-section-number">1.6.3</span> Note About Misleading Types</h3>
 <p>Sometimes, the types you see in GHCi are a bit different than what you’d assume. Here are two common cases.</p>
-<div class="sourceCode" id="cb17"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb17-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb17-2" data-line-number="2"><span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb17"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb17-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb17-2" title="2"><span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a</a></code></pre></div>
 <p>For now, you should read the type <code>Num a =&gt; a</code> as “any number type”. In Haskell, number literals are <em>overloaded</em> which means that they can be interpreted as any number type (e.g. <code>Int</code> or <code>Double</code>). We’ll get back to what <code>Num a</code> actually means when we talk about <em>type classes</em> later.</p>
-<div class="sourceCode" id="cb18"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb18-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="st">&quot;asdf&quot;</span></a>
-<a class="sourceLine" id="cb18-2" data-line-number="2"><span class="st">&quot;asdf&quot;</span><span class="ot"> ::</span> [<span class="dt">Char</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb18"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb18-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="st">&quot;asdf&quot;</span></a>
+<a class="sourceLine" id="cb18-2" title="2"><span class="st">&quot;asdf&quot;</span><span class="ot"> ::</span> [<span class="dt">Char</span>]</a></code></pre></div>
 <p>The type <code>String</code> is just an alias for the type <code>[Char]</code> which means “list of characters”. We’ll get back to lists on the next lecture! In any case, you can use <code>String</code> and <code>[Char]</code> interchangeably, but GHCi will mostly use <code>[Char]</code> when describing types to you.</p>
 <h2 id="the-structure-of-a-haskell-program"><span class="header-section-number">1.7</span> The Structure of a Haskell Program</h2>
 <p>Here’s a simple Haskell program that does some arithmetic and prints some values.</p>
-<div class="sourceCode" id="cb19"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb19-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb19-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb19-3" data-line-number="3"><span class="co">-- The golden ratio</span></a>
-<a class="sourceLine" id="cb19-4" data-line-number="4"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb19-5" data-line-number="5">phi <span class="fu">=</span> (sqrt <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb19-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb19-7" data-line-number="7"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb19-8" data-line-number="8">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb19-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb19-10" data-line-number="10">f x <span class="fu">=</span> polynomial (polynomial x)</a>
-<a class="sourceLine" id="cb19-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb19-12" data-line-number="12">main <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb19-13" data-line-number="13">  print (polynomial phi)</a>
-<a class="sourceLine" id="cb19-14" data-line-number="14">  print (f phi)</a></code></pre></div>
+<div class="sourceCode" id="cb19"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb19-1" title="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb19-2" title="2"></a>
+<a class="sourceLine" id="cb19-3" title="3"><span class="co">-- The golden ratio</span></a>
+<a class="sourceLine" id="cb19-4" title="4"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb19-5" title="5">phi <span class="fu">=</span> (<span class="fu">sqrt</span> <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb19-6" title="6"></a>
+<a class="sourceLine" id="cb19-7" title="7"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb19-8" title="8">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb19-9" title="9"></a>
+<a class="sourceLine" id="cb19-10" title="10">f x <span class="fu">=</span> polynomial (polynomial x)</a>
+<a class="sourceLine" id="cb19-11" title="11"></a>
+<a class="sourceLine" id="cb19-12" title="12">main <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb19-13" title="13">  <span class="fu">print</span> (polynomial phi)</a>
+<a class="sourceLine" id="cb19-14" title="14">  <span class="fu">print</span> (f phi)</a></code></pre></div>
 <p>If you put this in a file called <code>Gold.hs</code> and run it with (for example) <code>stack runhaskell Gold.hs</code>, you should see this output</p>
 <pre><code>0.0
 -1.0</code></pre>
 <p>Let’s walk through the file.</p>
-<div class="sourceCode" id="cb21"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb21-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a></code></pre></div>
+<div class="sourceCode" id="cb21"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb21-1" title="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a></code></pre></div>
 <p>There is one Haskell <em>module</em> per source file. A module consists of <em>definitions</em>.</p>
-<div class="sourceCode" id="cb22"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb22-1" data-line-number="1"><span class="co">-- The golden ratio</span></a></code></pre></div>
+<div class="sourceCode" id="cb22"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb22-1" title="1"><span class="co">-- The golden ratio</span></a></code></pre></div>
 <p>This is a comment. Comments are not part of the actual program, but text for human readers of the program.</p>
-<div class="sourceCode" id="cb23"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb23-1" data-line-number="1"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb23-2" data-line-number="2">phi <span class="fu">=</span> (sqrt <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb23"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb23-1" title="1"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb23-2" title="2">phi <span class="fu">=</span> (<span class="fu">sqrt</span> <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a></code></pre></div>
 <p>This is a definition of the constant <code>phi</code>, with an accompanying <em>type annotation</em> (also known as a <em>type signature</em>) <code>phi :: Double</code>. The type annotation means that <code>phi</code> has type <code>Double</code>. The line with a equals sign (<code>=</code>) is called an <em>equation</em>. The left hand side of the <code>=</code> is the expression we are defining, and the right hand side of the <code>=</code> is the definition.</p>
 <p>In general a definition (of a function or constant) consists of an optional <em>type annotation</em> and one or more <em>equations</em></p>
-<div class="sourceCode" id="cb24"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb24-1" data-line-number="1"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb24-2" data-line-number="2">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb24"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb24-1" title="1"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb24-2" title="2">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a></code></pre></div>
 <p>This is the definition of a function called <code>polynomial</code>. It has a type annotation and an equation. Note how an equation for a function differs from the equation of a constant by the presence of a parameter <code>x</code> left of the <code>=</code> sign. Note also that <code>^</code> is the power operator in Haskell, not bitwise xor like in many other languages.</p>
-<div class="sourceCode" id="cb25"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb25-1" data-line-number="1">f x <span class="fu">=</span> polynomial (polynomial x)</a></code></pre></div>
+<div class="sourceCode" id="cb25"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb25-1" title="1">f x <span class="fu">=</span> polynomial (polynomial x)</a></code></pre></div>
 <p>This is the definition of a function called <code>f</code>. Note the lack of type annotation. What is the type of <code>f</code>?</p>
-<div class="sourceCode" id="cb26"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb26-1" data-line-number="1">main <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb26-2" data-line-number="2">  print (polynomial phi)</a>
-<a class="sourceLine" id="cb26-3" data-line-number="3">  print (f phi)</a></code></pre></div>
+<div class="sourceCode" id="cb26"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb26-1" title="1">main <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb26-2" title="2">  <span class="fu">print</span> (polynomial phi)</a>
+<a class="sourceLine" id="cb26-3" title="3">  <span class="fu">print</span> (f phi)</a></code></pre></div>
 <p>This is a description of what happens when you run the program. It uses do-syntax and the IO Monad. We’ll get back to those in part 2 of the course.</p>
 <h2 id="working-with-examples"><span class="header-section-number">1.8</span> Working with Examples</h2>
 <p>When you see an example definition like this</p>
-<div class="sourceCode" id="cb27"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb27-1" data-line-number="1"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb27-2" data-line-number="2">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb27"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb27-1" title="1"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb27-2" title="2">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a></code></pre></div>
 <p>you should usually play around with it. Start by running it. There are a couple of ways to do this.</p>
 <p>If a definition fits on one line, you can just define it in GHCi using <code>let</code>:</p>
 <pre><code>Prelude&gt; let polynomial x = x^2 - x - 1
 Prelude&gt; polynomial 3.0
 5.0</code></pre>
 <p>For a multi-line definition, you can either use <code>;</code> to separate lines, or use the special <code>:{ :}</code> syntax to paste a block of code into GHCi:</p>
-<div class="sourceCode" id="cb29"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb29-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>{</a>
-<a class="sourceLine" id="cb29-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">|</span><span class="ot"> polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb29-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">|</span> polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb29-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">|</span> <span class="fu">:</span>}</a>
-<a class="sourceLine" id="cb29-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> polynomial <span class="fl">3.0</span></a>
-<a class="sourceLine" id="cb29-6" data-line-number="6"><span class="fl">5.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb29"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb29-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>{</a>
+<a class="sourceLine" id="cb29-2" title="2"><span class="dt">Prelude</span><span class="fu">|</span><span class="ot"> polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb29-3" title="3"><span class="dt">Prelude</span><span class="fu">|</span> polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb29-4" title="4"><span class="dt">Prelude</span><span class="fu">|</span> <span class="fu">:</span>}</a>
+<a class="sourceLine" id="cb29-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> polynomial <span class="fl">3.0</span></a>
+<a class="sourceLine" id="cb29-6" title="6"><span class="fl">5.0</span></a></code></pre></div>
 <p>Finally, you can paste the code into a new or existing <code>.hs</code> file, and then <code>:load</code> it into GHCi. If the file has already been loaded, you can also use <code>:reload</code>.</p>
-<div class="sourceCode" id="cb30"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb30-1" data-line-number="1"><span class="co">-- first copy and paste the definition into Example.hs, then run GHCi</span></a>
-<a class="sourceLine" id="cb30-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>load Example.hs</a>
-<a class="sourceLine" id="cb30-3" data-line-number="3">[<span class="dv">1</span> <span class="kw">of</span> <span class="dv">1</span>] <span class="dt">Compiling</span> <span class="dt">Main</span>             ( Example.hs, interpreted )</a>
-<a class="sourceLine" id="cb30-4" data-line-number="4"><span class="dt">Ok</span>, one <span class="kw">module</span> loaded<span class="fu">.</span></a>
-<a class="sourceLine" id="cb30-5" data-line-number="5"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> polynomial <span class="fl">3.0</span></a>
-<a class="sourceLine" id="cb30-6" data-line-number="6"><span class="fl">5.0</span></a>
-<a class="sourceLine" id="cb30-7" data-line-number="7"><span class="co">-- now you can edit the definition</span></a>
-<a class="sourceLine" id="cb30-8" data-line-number="8"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>reload</a>
-<a class="sourceLine" id="cb30-9" data-line-number="9">[<span class="dv">1</span> <span class="kw">of</span> <span class="dv">1</span>] <span class="dt">Compiling</span> <span class="dt">Main</span>             ( Example.hs, interpreted )</a>
-<a class="sourceLine" id="cb30-10" data-line-number="10"><span class="dt">Ok</span>, one <span class="kw">module</span> loaded<span class="fu">.</span></a>
-<a class="sourceLine" id="cb30-11" data-line-number="11"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> polynomial <span class="dv">3</span></a>
-<a class="sourceLine" id="cb30-12" data-line-number="12"><span class="fl">3.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb30"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb30-1" title="1"><span class="co">-- first copy and paste the definition into Example.hs, then run GHCi</span></a>
+<a class="sourceLine" id="cb30-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>load Example.hs</a>
+<a class="sourceLine" id="cb30-3" title="3">[<span class="dv">1</span> <span class="kw">of</span> <span class="dv">1</span>] <span class="dt">Compiling</span> <span class="dt">Main</span>             ( Example.hs, interpreted )</a>
+<a class="sourceLine" id="cb30-4" title="4"><span class="dt">Ok</span>, one <span class="kw">module</span> loaded<span class="fu">.</span></a>
+<a class="sourceLine" id="cb30-5" title="5"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> polynomial <span class="fl">3.0</span></a>
+<a class="sourceLine" id="cb30-6" title="6"><span class="fl">5.0</span></a>
+<a class="sourceLine" id="cb30-7" title="7"><span class="co">-- now you can edit the definition</span></a>
+<a class="sourceLine" id="cb30-8" title="8"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>reload</a>
+<a class="sourceLine" id="cb30-9" title="9">[<span class="dv">1</span> <span class="kw">of</span> <span class="dv">1</span>] <span class="dt">Compiling</span> <span class="dt">Main</span>             ( Example.hs, interpreted )</a>
+<a class="sourceLine" id="cb30-10" title="10"><span class="dt">Ok</span>, one <span class="kw">module</span> loaded<span class="fu">.</span></a>
+<a class="sourceLine" id="cb30-11" title="11"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> polynomial <span class="dv">3</span></a>
+<a class="sourceLine" id="cb30-12" title="12"><span class="fl">3.0</span></a></code></pre></div>
 <p>After you’ve run the example, try modifying it, or making another function that is similar but different. You learn programming by programming, not by reading!</p>
 <h3 id="dealing-with-errors"><span class="header-section-number">1.8.1</span> Dealing with Errors</h3>
 <p>Since Haskell is a typed language, you’ll pretty quickly bump into type errors. Here’s an example of an error during a GHCi session:</p>
-<div class="sourceCode" id="cb31"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb31-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb31-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb31-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">13</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb31-4" data-line-number="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘[<span class="dt">Char</span>]’ with actual <span class="kw">type</span> ‘<span class="dt">Bool</span>’</a>
-<a class="sourceLine" id="cb31-5" data-line-number="5">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">++</span>)’, namely ‘<span class="dt">True</span>’</a>
-<a class="sourceLine" id="cb31-6" data-line-number="6">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb31-7" data-line-number="7">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb31"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb31-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb31-2" title="2"></a>
+<a class="sourceLine" id="cb31-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">13</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb31-4" title="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘[<span class="dt">Char</span>]’ with actual <span class="kw">type</span> ‘<span class="dt">Bool</span>’</a>
+<a class="sourceLine" id="cb31-5" title="5">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">++</span>)’, namely ‘<span class="dt">True</span>’</a>
+<a class="sourceLine" id="cb31-6" title="6">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb31-7" title="7">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="st">&quot;string&quot;</span> <span class="fu">++</span> <span class="dt">True</span></a></code></pre></div>
 <p>This is the most common type error, “Couldn’t match expected type”. Even though the error looks long and scary, it’s pretty simple if you just read through it.</p>
 <ul>
 <li><p>The first line of the error message, <code>&lt;interactive&gt;:1:13: error:</code> tells us that the error occurred in GHCi. If we had loaded a file, we might instead get something like <code>Sandbox.hs:3:17: error:</code>, where <code>Sandbox.hs</code> is the name of the file, <code>3</code> is the line number and <code>17</code> is the number of a character in the line.</p></li>
-<li><p>The line <code>• Couldn't match expected type ‘[Char]’ with actual type ‘Bool’</code> tells us that the immediate cause for the error is that there was an expression of type <code>Bool</code>, when GHCi was expecting to find an expression of type <code>[Char]</code>“. The location of this error was indicated in the first line of the error message. Note that the expected type is not always right. Giving type annotations by hand can help debugging typing errors.</p></li>
+<li><p>The line <code>• Couldn't match expected type ‘[Char]’ with actual type ‘Bool’</code> tells us that the immediate cause for the error is that there was an expression of type <code>Bool</code>, when GHCi was expecting to find an expression of type <code>[Char]</code>&quot;. The location of this error was indicated in the first line of the error message. Note that the expected type is not always right. Giving type annotations by hand can help debugging typing errors.</p></li>
 <li><p>The line <code>• In the second argument of ‘(++)’, namely ‘True’</code> tells that the expression that had the wrong type was the second argument of the operator <code>(++)</code>. We’ll learn later why it’s surrounded by parentheses.</p></li>
 <li><p>The full expression with the error was <code>&quot;string&quot; ++ True</code>. As mentioned above, <code>String</code> is a type alias for <code>[Char]</code>, the type of character lists. The first argument to <code>++</code> was a list of characters, and since <code>++</code> can only combine two lists of the same type, the second argument should’ve been of type <code>[Char]</code> too.</p></li>
 <li><p>The line <code>In an equation for ‘it’: it = &quot;string&quot; ++ True</code> says that the expression occurred in the definition of the variable <code>it</code>, which is a default variable name that GHCi uses for standalone expressions. If we had a line <code>x = &quot;string&quot; ++ True</code> in a file, or a declaration <code>let x = &quot;string&quot; ++ True</code> in GHCi, GHCi would print <code>In an equation for ‘x’: x = &quot;string&quot; ++ True</code> instead.</p></li>
 </ul>
 <p>There are also others types of errors.</p>
-<div class="sourceCode" id="cb32"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb32-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb32-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb32-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">6</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb32-4" data-line-number="4">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Num</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘<span class="fu">+</span>’</a>
-<a class="sourceLine" id="cb32-5" data-line-number="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb32-6" data-line-number="6">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb32"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb32-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb32-2" title="2"></a>
+<a class="sourceLine" id="cb32-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">6</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb32-4" title="4">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Num</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘<span class="fu">+</span>’</a>
+<a class="sourceLine" id="cb32-5" title="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb32-6" title="6">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">True</span> <span class="fu">+</span> <span class="dv">1</span></a></code></pre></div>
 <p>This is the kind of error you get when you try to use a numeric function like <code>+</code> on something that’s not a number.</p>
 <p>The hardest error to track down is usually this:</p>
-<div class="sourceCode" id="cb33"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb33-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span> <span class="fu">+</span></a>
-<a class="sourceLine" id="cb33-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb33-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">10</span><span class="fu">:</span><span class="dv">7</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb33-4" data-line-number="4">    parse error (possibly incorrect indentation or mismatched brackets)</a></code></pre></div>
+<div class="sourceCode" id="cb33"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb33-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span> <span class="fu">+</span></a>
+<a class="sourceLine" id="cb33-2" title="2"></a>
+<a class="sourceLine" id="cb33-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">10</span><span class="fu">:</span><span class="dv">7</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb33-4" title="4">    parse <span class="fu">error</span> (possibly incorrect indentation <span class="fu">or</span> mismatched brackets)</a></code></pre></div>
 <p>There are many ways to cause it. Probably you’re missing some characters somewhere. We’ll get back to indentation later in this lecture.</p>
 <!-- TODO more errors based on feedback -->
 <h3 id="arithmetic"><span class="header-section-number">1.8.2</span> Arithmetic</h3>
 <p>There’s one thing in Haskell arithmetic that often trips up beginners, and that’s division.</p>
 <p>In Haskell there are two division functions, the <code>/</code> operator and the <code>div</code> function. The <code>div</code> function does integer division:</p>
-<div class="sourceCode" id="cb34"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb34-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">7</span> <span class="ot">`div`</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb34-2" data-line-number="2"><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb34"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb34-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">7</span> <span class="ot">`div`</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb34-2" title="2"><span class="dv">3</span></a></code></pre></div>
 <p>The <code>/</code> operator performs the usual division:</p>
-<div class="sourceCode" id="cb35"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb35-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fl">7.0</span> <span class="fu">/</span> <span class="fl">2.0</span></a>
-<a class="sourceLine" id="cb35-2" data-line-number="2"><span class="fl">3.5</span></a></code></pre></div>
+<div class="sourceCode" id="cb35"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb35-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fl">7.0</span> <span class="fu">/</span> <span class="fl">2.0</span></a>
+<a class="sourceLine" id="cb35-2" title="2"><span class="fl">3.5</span></a></code></pre></div>
 <p>However, you can only use <code>div</code> on whole number types like <code>Int</code> and <code>Integer</code>, and you can only use <code>/</code> on decimal types like <code>Double</code>. Here’s an example of what happens if you try to mix them up:</p>
-<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb36-1" data-line-number="1"><span class="ot">halve ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb36-2" data-line-number="2">halve x <span class="fu">=</span> x <span class="fu">/</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb36-1" title="1"><span class="ot">halve ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb36-2" title="2">halve x <span class="fu">=</span> x <span class="fu">/</span> <span class="dv">2</span></a></code></pre></div>
 <pre><code>error:
     • No instance for (Fractional Int) arising from a use of ‘/’
     • In the expression: x / 2
@@ -609,149 +607,149 @@ Prelude&gt; polynomial 3.0
 <h3 id="conditionals"><span class="header-section-number">1.9.1</span> Conditionals</h3>
 <p>In other languages, <code>if</code> is a <em>statement</em>. It doesn’t have a value, it just conditionally executes other statements.</p>
 <p>In Haskell, <code>if</code> is an <em>expression</em>. It has a value. It selects between two other expressions. It corresponds to the <code>?:</code> operator in C or Java.</p>
-<div class="sourceCode" id="cb38"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb38-1" data-line-number="1"><span class="co">// Java</span></a>
-<a class="sourceLine" id="cb38-2" data-line-number="2"><span class="dt">int</span> price = product.<span class="fu">equals</span>(<span class="st">&quot;milk&quot;</span>) ? <span class="dv">1</span> : <span class="dv">2</span>;</a></code></pre></div>
+<div class="sourceCode" id="cb38"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb38-1" title="1"><span class="co">// Java</span></a>
+<a class="sourceLine" id="cb38-2" title="2"><span class="dt">int</span> price = product.<span class="fu">equals</span>(<span class="st">&quot;milk&quot;</span>) ? <span class="dv">1</span> : <span class="dv">2</span>;</a></code></pre></div>
 <p>Python’s conditional expressions are quite close to haskell’s <code>if</code>:</p>
-<div class="sourceCode" id="cb39"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb39-1" data-line-number="1"><span class="co"># Python</span></a>
-<a class="sourceLine" id="cb39-2" data-line-number="2">price <span class="op">=</span> <span class="dv">1</span> <span class="cf">if</span> product <span class="op">==</span> <span class="st">&quot;milk&quot;</span> <span class="cf">else</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb39"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb39-1" title="1"><span class="co"># Python</span></a>
+<a class="sourceLine" id="cb39-2" title="2">price <span class="op">=</span> <span class="dv">1</span> <span class="cf">if</span> product <span class="op">==</span> <span class="st">&quot;milk&quot;</span> <span class="cf">else</span> <span class="dv">2</span></a></code></pre></div>
 <p>This is how the same example looks in Haskell:</p>
-<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb40-1" data-line-number="1">price <span class="fu">=</span> <span class="kw">if</span> product <span class="fu">==</span> <span class="st">&quot;milk&quot;</span> <span class="kw">then</span> <span class="dv">1</span> <span class="kw">else</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb40-1" title="1">price <span class="fu">=</span> <span class="kw">if</span> <span class="fu">product</span> <span class="fu">==</span> <span class="st">&quot;milk&quot;</span> <span class="kw">then</span> <span class="dv">1</span> <span class="kw">else</span> <span class="dv">2</span></a></code></pre></div>
 <p>Because Haskell’s <code>if</code> <em>returns</em> a value, you <strong>always</strong> need an <code>else</code>!</p>
 <h4 id="functions-returning-bool"><span class="header-section-number">1.9.1.1</span> Functions Returning <code>Bool</code></h4>
 <p>In order to write if expressions, you need to know how to get values of type <code>Bool</code>. The most common way is comparisons. The usual <code>==</code>, <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code> and <code>&gt;=</code> operators work in Haskell. You can do ordered comparisons (<code>&lt;</code>, <code>&gt;</code>) on all sorts of numbers, and equality comparisons (<code>==</code>) on almost anything:</p>
-<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb41-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;foo&quot;</span> <span class="fu">==</span> <span class="st">&quot;bar&quot;</span></a>
-<a class="sourceLine" id="cb41-2" data-line-number="2"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb41-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fl">5.0</span> <span class="fu">&lt;=</span> <span class="fl">7.2</span></a>
-<a class="sourceLine" id="cb41-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb41-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb41-6" data-line-number="6"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb41-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;foo&quot;</span> <span class="fu">==</span> <span class="st">&quot;bar&quot;</span></a>
+<a class="sourceLine" id="cb41-2" title="2"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb41-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fl">5.0</span> <span class="fu">&lt;=</span> <span class="fl">7.2</span></a>
+<a class="sourceLine" id="cb41-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb41-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb41-6" title="6"><span class="dt">True</span></a></code></pre></div>
 <p>One oddity of Haskell is that the not-equals operator is written <code>/=</code> instead of the usual <code>!=</code>:</p>
-<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb42-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">2</span> <span class="fu">/=</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb42-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb42-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;bike&quot;</span> <span class="fu">/=</span> <span class="st">&quot;bike&quot;</span></a>
-<a class="sourceLine" id="cb42-4" data-line-number="4"><span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb42-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">2</span> <span class="fu">/=</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb42-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb42-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;bike&quot;</span> <span class="fu">/=</span> <span class="st">&quot;bike&quot;</span></a>
+<a class="sourceLine" id="cb42-4" title="4"><span class="dt">False</span></a></code></pre></div>
 <p>Remember that in addition to these comparisons, you can get <code>Bool</code> values out of other <code>Bool</code> values by using the <code>&amp;&amp;</code> (“and”) and <code>||</code> (“or”) operators, and the <code>not</code> function.</p>
 <h4 id="examples"><span class="header-section-number">1.9.1.2</span> Examples</h4>
-<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb43-1" data-line-number="1">checkPassword password <span class="fu">=</span> <span class="kw">if</span> password <span class="fu">==</span> <span class="st">&quot;swordfish&quot;</span></a>
-<a class="sourceLine" id="cb43-2" data-line-number="2">                         <span class="kw">then</span> <span class="st">&quot;You&#39;re in.&quot;</span></a>
-<a class="sourceLine" id="cb43-3" data-line-number="3">                         <span class="kw">else</span> <span class="st">&quot;ACCESS DENIED!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb44-1" data-line-number="1">absoluteValue n <span class="fu">=</span> <span class="kw">if</span> n <span class="fu">&lt;</span> <span class="dv">0</span> <span class="kw">then</span> <span class="fu">-</span>n <span class="kw">else</span> n</a></code></pre></div>
-<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb45-1" data-line-number="1">login user password <span class="fu">=</span> <span class="kw">if</span> user <span class="fu">==</span> <span class="st">&quot;unicorn73&quot;</span></a>
-<a class="sourceLine" id="cb45-2" data-line-number="2">                      <span class="kw">then</span> <span class="kw">if</span> password <span class="fu">==</span> <span class="st">&quot;f4bulous!&quot;</span></a>
-<a class="sourceLine" id="cb45-3" data-line-number="3">                           <span class="kw">then</span> <span class="st">&quot;unicorn73 logged in&quot;</span></a>
-<a class="sourceLine" id="cb45-4" data-line-number="4">                           <span class="kw">else</span> <span class="st">&quot;wrong password&quot;</span></a>
-<a class="sourceLine" id="cb45-5" data-line-number="5">                      <span class="kw">else</span> <span class="st">&quot;unknown user&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb43-1" title="1">checkPassword password <span class="fu">=</span> <span class="kw">if</span> password <span class="fu">==</span> <span class="st">&quot;swordfish&quot;</span></a>
+<a class="sourceLine" id="cb43-2" title="2">                         <span class="kw">then</span> <span class="st">&quot;You&#39;re in.&quot;</span></a>
+<a class="sourceLine" id="cb43-3" title="3">                         <span class="kw">else</span> <span class="st">&quot;ACCESS DENIED!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb44-1" title="1">absoluteValue n <span class="fu">=</span> <span class="kw">if</span> n <span class="fu">&lt;</span> <span class="dv">0</span> <span class="kw">then</span> <span class="fu">-</span>n <span class="kw">else</span> n</a></code></pre></div>
+<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb45-1" title="1">login user password <span class="fu">=</span> <span class="kw">if</span> user <span class="fu">==</span> <span class="st">&quot;unicorn73&quot;</span></a>
+<a class="sourceLine" id="cb45-2" title="2">                      <span class="kw">then</span> <span class="kw">if</span> password <span class="fu">==</span> <span class="st">&quot;f4bulous!&quot;</span></a>
+<a class="sourceLine" id="cb45-3" title="3">                           <span class="kw">then</span> <span class="st">&quot;unicorn73 logged in&quot;</span></a>
+<a class="sourceLine" id="cb45-4" title="4">                           <span class="kw">else</span> <span class="st">&quot;wrong password&quot;</span></a>
+<a class="sourceLine" id="cb45-5" title="5">                      <span class="kw">else</span> <span class="st">&quot;unknown user&quot;</span></a></code></pre></div>
 <h3 id="local-definitions"><span class="header-section-number">1.9.2</span> Local Definitions</h3>
 <p>Haskell has two different ways for creating local definitions: <code>let...in</code> and <code>where</code>.</p>
 <p><code>where</code> adds local definitions to a definition:</p>
-<div class="sourceCode" id="cb46"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb46-1" data-line-number="1"><span class="ot">circleArea ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb46-2" data-line-number="2">circleArea r <span class="fu">=</span> pi <span class="fu">*</span> rsquare</a>
-<a class="sourceLine" id="cb46-3" data-line-number="3">    <span class="kw">where</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb46-4" data-line-number="4">          rsquare <span class="fu">=</span> r <span class="fu">*</span> r</a></code></pre></div>
+<div class="sourceCode" id="cb46"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb46-1" title="1"><span class="ot">circleArea ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb46-2" title="2">circleArea r <span class="fu">=</span> <span class="fu">pi</span> <span class="fu">*</span> rsquare</a>
+<a class="sourceLine" id="cb46-3" title="3">    <span class="kw">where</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb46-4" title="4">          rsquare <span class="fu">=</span> r <span class="fu">*</span> r</a></code></pre></div>
 <p><code>let...in</code> is an expression:</p>
-<div class="sourceCode" id="cb47"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb47-1" data-line-number="1">circleArea r <span class="fu">=</span> <span class="kw">let</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb47-2" data-line-number="2">                   rsquare <span class="fu">=</span> r <span class="fu">*</span> r</a>
-<a class="sourceLine" id="cb47-3" data-line-number="3">               <span class="kw">in</span> pi <span class="fu">*</span> rsquare</a></code></pre></div>
+<div class="sourceCode" id="cb47"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb47-1" title="1">circleArea r <span class="fu">=</span> <span class="kw">let</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb47-2" title="2">                   rsquare <span class="fu">=</span> r <span class="fu">*</span> r</a>
+<a class="sourceLine" id="cb47-3" title="3">               <span class="kw">in</span> <span class="fu">pi</span> <span class="fu">*</span> rsquare</a></code></pre></div>
 <p>Local definitions can also be functions:</p>
-<div class="sourceCode" id="cb48"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb48-1" data-line-number="1">circleArea r <span class="fu">=</span> pi <span class="fu">*</span> square r</a>
-<a class="sourceLine" id="cb48-2" data-line-number="2">    <span class="kw">where</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb48-3" data-line-number="3">          square x <span class="fu">=</span> x <span class="fu">*</span> x</a></code></pre></div>
-<div class="sourceCode" id="cb49"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb49-1" data-line-number="1">circleArea r <span class="fu">=</span> <span class="kw">let</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb49-2" data-line-number="2">                   square x <span class="fu">=</span> x <span class="fu">*</span> x</a>
-<a class="sourceLine" id="cb49-3" data-line-number="3">               <span class="kw">in</span> pi <span class="fu">*</span> square r</a></code></pre></div>
+<div class="sourceCode" id="cb48"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb48-1" title="1">circleArea r <span class="fu">=</span> <span class="fu">pi</span> <span class="fu">*</span> square r</a>
+<a class="sourceLine" id="cb48-2" title="2">    <span class="kw">where</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb48-3" title="3">          square x <span class="fu">=</span> x <span class="fu">*</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb49"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb49-1" title="1">circleArea r <span class="fu">=</span> <span class="kw">let</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb49-2" title="2">                   square x <span class="fu">=</span> x <span class="fu">*</span> x</a>
+<a class="sourceLine" id="cb49-3" title="3">               <span class="kw">in</span> <span class="fu">pi</span> <span class="fu">*</span> square r</a></code></pre></div>
 <p>We’ll get back to the differences between <code>let</code> and <code>where</code>, but mostly you can use which ever you like.</p>
 <h3 id="a-word-about-immutability"><span class="header-section-number">1.9.3</span> A Word About Immutability</h3>
 <p>Even though things like <code>pi</code> above are often called <em>variables</em>, I’ve chosen to call them <em>definitions</em> here. This is because unlike variables in Python or Java, the values of these definitions can’t be changed. Haskell variables aren’t boxes into which you can put new values, Haskell variables name a value (or rather, an expression) and that’s it.</p>
 <p>We’ll talk about immutability again later on this course, but for now it’s enough to know that things like this don’t work.</p>
-<div class="sourceCode" id="cb50"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb50-1" data-line-number="1">increment x <span class="fu">=</span> <span class="kw">let</span> x <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb50-2" data-line-number="2">              <span class="kw">in</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb50"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb50-1" title="1">increment x <span class="fu">=</span> <span class="kw">let</span> x <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb50-2" title="2">              <span class="kw">in</span> x</a></code></pre></div>
 <p>This is just an infinite loop, because it tries to define a new variable <code>x</code> with the property <code>x = x+1</code>. Thus when evaluating <code>x</code>, Haskell just keeps computing <code>1+1+1+1+...</code> indefinitely.</p>
-<div class="sourceCode" id="cb51"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb51-1" data-line-number="1">compute x <span class="fu">=</span> <span class="kw">let</span> a <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb51-2" data-line-number="2">                a <span class="fu">=</span> a<span class="fu">*</span><span class="dv">2</span></a>
-<a class="sourceLine" id="cb51-3" data-line-number="3">            <span class="kw">in</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb51"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb51-1" title="1">compute x <span class="fu">=</span> <span class="kw">let</span> a <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb51-2" title="2">                a <span class="fu">=</span> a<span class="fu">*</span><span class="dv">2</span></a>
+<a class="sourceLine" id="cb51-3" title="3">            <span class="kw">in</span> a</a></code></pre></div>
 <pre><code>error:
     Conflicting definitions for ‘a’
     Bound at: &lt;interactive&gt;:14:17
               &lt;interactive&gt;:15:17</code></pre>
 <p>Here we get a straightforward error when we’re trying to “update” the value of <code>a</code>.</p>
 <p>As a remark, local definitions can <em>shadow</em> the names of variables defined elsewhere. Shadowing is not a side-effect. Instead, shadowing creates a new variable within a more restricted scope that uses the same name as some variable in the outer scope. For example, all of the functions <code>f</code>, <code>g</code>, and <code>h</code> below are legal:</p>
-<div class="sourceCode" id="cb53"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb53-1" data-line-number="1"><span class="ot">x ::</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-2" data-line-number="2">x <span class="fu">=</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb53-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb53-4" data-line-number="4"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-5" data-line-number="5">f x <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> x</a>
-<a class="sourceLine" id="cb53-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb53-7" data-line-number="7"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-8" data-line-number="8">g y <span class="fu">=</span> x <span class="kw">where</span> x <span class="fu">=</span> <span class="dv">6</span></a>
-<a class="sourceLine" id="cb53-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb53-10" data-line-number="10"><span class="ot">h ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-11" data-line-number="11">h x <span class="fu">=</span> x <span class="kw">where</span> x <span class="fu">=</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb53"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb53-1" title="1"><span class="ot">x ::</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-2" title="2">x <span class="fu">=</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb53-3" title="3"></a>
+<a class="sourceLine" id="cb53-4" title="4"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-5" title="5">f x <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> x</a>
+<a class="sourceLine" id="cb53-6" title="6"></a>
+<a class="sourceLine" id="cb53-7" title="7"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-8" title="8">g y <span class="fu">=</span> x <span class="kw">where</span> x <span class="fu">=</span> <span class="dv">6</span></a>
+<a class="sourceLine" id="cb53-9" title="9"></a>
+<a class="sourceLine" id="cb53-10" title="10"><span class="ot">h ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-11" title="11">h x <span class="fu">=</span> x <span class="kw">where</span> x <span class="fu">=</span> <span class="dv">3</span></a></code></pre></div>
 <p>If we apply them to the global constant <code>x</code>, we see the effects of shadowing:</p>
-<div class="sourceCode" id="cb54"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb54-1" data-line-number="1">f <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb54-2" data-line-number="2">g <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">6</span></a>
-<a class="sourceLine" id="cb54-3" data-line-number="3">h <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb54-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb54-5" data-line-number="5">f x <span class="fu">==&gt;</span> <span class="dv">10</span></a>
-<a class="sourceLine" id="cb54-6" data-line-number="6">g x <span class="fu">==&gt;</span> <span class="dv">6</span></a>
-<a class="sourceLine" id="cb54-7" data-line-number="7">h x <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb54"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb54-1" title="1">f <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb54-2" title="2">g <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">6</span></a>
+<a class="sourceLine" id="cb54-3" title="3">h <span class="dv">1</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb54-4" title="4"></a>
+<a class="sourceLine" id="cb54-5" title="5">f x <span class="fu">==&gt;</span> <span class="dv">10</span></a>
+<a class="sourceLine" id="cb54-6" title="6">g x <span class="fu">==&gt;</span> <span class="dv">6</span></a>
+<a class="sourceLine" id="cb54-7" title="7">h x <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>It is best to always choose new names for local variables, so that shadowing never happens. That way, the reader of the code will understand where the variables that are used in an expression come from. Note that in the following example, <code>f</code> and <code>g</code> don’t shadow each others’ arguments:</p>
-<div class="sourceCode" id="cb55"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb55-1" data-line-number="1"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb55-2" data-line-number="2">f x <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> x <span class="fu">+</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb55-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb55-4" data-line-number="4"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb55-5" data-line-number="5">g x <span class="fu">=</span> x <span class="fu">-</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb55"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb55-1" title="1"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb55-2" title="2">f x <span class="fu">=</span> <span class="dv">2</span> <span class="fu">*</span> x <span class="fu">+</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb55-3" title="3"></a>
+<a class="sourceLine" id="cb55-4" title="4"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb55-5" title="5">g x <span class="fu">=</span> x <span class="fu">-</span> <span class="dv">2</span></a></code></pre></div>
 <h3 id="pattern-matching"><span class="header-section-number">1.9.4</span> Pattern Matching</h3>
 <p>A definition (of a function) can consist of multiple <em>equations</em>. The equations are matched in order against the arguments until a suitable one is found. This is called <em>pattern matching</em>.</p>
 <p>Pattern matching in Haskell is very powerful, and we’ll keep learning new things about it along this course, but here are a couple of first examples:</p>
-<div class="sourceCode" id="cb56"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb56-1" data-line-number="1"><span class="ot">greet ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb56-2" data-line-number="2">greet <span class="st">&quot;Finland&quot;</span> name <span class="fu">=</span> <span class="st">&quot;Hei, &quot;</span> <span class="fu">++</span> name</a>
-<a class="sourceLine" id="cb56-3" data-line-number="3">greet <span class="st">&quot;Italy&quot;</span>   name <span class="fu">=</span> <span class="st">&quot;Ciao, &quot;</span> <span class="fu">++</span> name</a>
-<a class="sourceLine" id="cb56-4" data-line-number="4">greet <span class="st">&quot;England&quot;</span> name <span class="fu">=</span> <span class="st">&quot;How do you do, &quot;</span> <span class="fu">++</span> name</a>
-<a class="sourceLine" id="cb56-5" data-line-number="5">greet _         name <span class="fu">=</span> <span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name</a></code></pre></div>
+<div class="sourceCode" id="cb56"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb56-1" title="1"><span class="ot">greet ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb56-2" title="2">greet <span class="st">&quot;Finland&quot;</span> name <span class="fu">=</span> <span class="st">&quot;Hei, &quot;</span> <span class="fu">++</span> name</a>
+<a class="sourceLine" id="cb56-3" title="3">greet <span class="st">&quot;Italy&quot;</span>   name <span class="fu">=</span> <span class="st">&quot;Ciao, &quot;</span> <span class="fu">++</span> name</a>
+<a class="sourceLine" id="cb56-4" title="4">greet <span class="st">&quot;England&quot;</span> name <span class="fu">=</span> <span class="st">&quot;How do you do, &quot;</span> <span class="fu">++</span> name</a>
+<a class="sourceLine" id="cb56-5" title="5">greet _         name <span class="fu">=</span> <span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name</a></code></pre></div>
 <p>The function <code>greet</code> generates a greeting given a country and a name (both <code>String</code>s). It has special cases for three countries, and a default case. This is how it works:</p>
-<div class="sourceCode" id="cb57"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb57-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Pekka&quot;</span></a>
-<a class="sourceLine" id="cb57-2" data-line-number="2"><span class="st">&quot;Hei, Pekka&quot;</span></a>
-<a class="sourceLine" id="cb57-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;England&quot;</span> <span class="st">&quot;Bob&quot;</span></a>
-<a class="sourceLine" id="cb57-4" data-line-number="4"><span class="st">&quot;How do you do, Bob&quot;</span></a>
-<a class="sourceLine" id="cb57-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Italy&quot;</span> <span class="st">&quot;Maria&quot;</span></a>
-<a class="sourceLine" id="cb57-6" data-line-number="6"><span class="st">&quot;Ciao, Maria&quot;</span></a>
-<a class="sourceLine" id="cb57-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Greenland&quot;</span> <span class="st">&quot;Jan&quot;</span></a>
-<a class="sourceLine" id="cb57-8" data-line-number="8"><span class="st">&quot;Hello, Jan&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb57"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb57-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Pekka&quot;</span></a>
+<a class="sourceLine" id="cb57-2" title="2"><span class="st">&quot;Hei, Pekka&quot;</span></a>
+<a class="sourceLine" id="cb57-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;England&quot;</span> <span class="st">&quot;Bob&quot;</span></a>
+<a class="sourceLine" id="cb57-4" title="4"><span class="st">&quot;How do you do, Bob&quot;</span></a>
+<a class="sourceLine" id="cb57-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Italy&quot;</span> <span class="st">&quot;Maria&quot;</span></a>
+<a class="sourceLine" id="cb57-6" title="6"><span class="st">&quot;Ciao, Maria&quot;</span></a>
+<a class="sourceLine" id="cb57-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet <span class="st">&quot;Greenland&quot;</span> <span class="st">&quot;Jan&quot;</span></a>
+<a class="sourceLine" id="cb57-8" title="8"><span class="st">&quot;Hello, Jan&quot;</span></a></code></pre></div>
 <p>The special pattern <code>_</code> matches anything. It’s usually used for default cases. Because patterns are matched in order, it’s important to (<em>usually</em>) put the <code>_</code> case last. Consider:</p>
-<div class="sourceCode" id="cb58"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb58-1" data-line-number="1">brokenGreet _         name <span class="fu">=</span> <span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name</a>
-<a class="sourceLine" id="cb58-2" data-line-number="2">brokenGreet <span class="st">&quot;Finland&quot;</span> name <span class="fu">=</span> <span class="st">&quot;Hei, &quot;</span> <span class="fu">++</span> name</a></code></pre></div>
+<div class="sourceCode" id="cb58"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb58-1" title="1">brokenGreet _         name <span class="fu">=</span> <span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name</a>
+<a class="sourceLine" id="cb58-2" title="2">brokenGreet <span class="st">&quot;Finland&quot;</span> name <span class="fu">=</span> <span class="st">&quot;Hei, &quot;</span> <span class="fu">++</span> name</a></code></pre></div>
 <p>Now the first case gets selected for all inputs.</p>
-<div class="sourceCode" id="cb59"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb59-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> brokenGreet <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Varpu&quot;</span></a>
-<a class="sourceLine" id="cb59-2" data-line-number="2"><span class="st">&quot;Hello, Varpu&quot;</span></a>
-<a class="sourceLine" id="cb59-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> brokenGreet <span class="st">&quot;Sweden&quot;</span> <span class="st">&quot;Ole&quot;</span></a>
-<a class="sourceLine" id="cb59-4" data-line-number="4"><span class="st">&quot;Hello, Ole&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb59"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb59-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> brokenGreet <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Varpu&quot;</span></a>
+<a class="sourceLine" id="cb59-2" title="2"><span class="st">&quot;Hello, Varpu&quot;</span></a>
+<a class="sourceLine" id="cb59-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> brokenGreet <span class="st">&quot;Sweden&quot;</span> <span class="st">&quot;Ole&quot;</span></a>
+<a class="sourceLine" id="cb59-4" title="4"><span class="st">&quot;Hello, Ole&quot;</span></a></code></pre></div>
 <p>GHC even gives you a warning about this code:</p>
 <pre><code>&lt;interactive&gt;:1:1: warning: [-Woverlapping-patterns]
     Pattern match is redundant
     In an equation for ‘brokenGreet’: brokenGreet &quot;Finland&quot; name = ...</code></pre>
 <p>Some more examples follow. But first let’s introduce the standard library function <code>show</code> that can turn (almost!) anything into a string:</p>
-<div class="sourceCode" id="cb61"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb61-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> show <span class="dt">True</span></a>
-<a class="sourceLine" id="cb61-2" data-line-number="2"><span class="st">&quot;True&quot;</span></a>
-<a class="sourceLine" id="cb61-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> show <span class="dv">3</span></a>
-<a class="sourceLine" id="cb61-4" data-line-number="4"><span class="st">&quot;3&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb61"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb61-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">show</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb61-2" title="2"><span class="st">&quot;True&quot;</span></a>
+<a class="sourceLine" id="cb61-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">show</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb61-4" title="4"><span class="st">&quot;3&quot;</span></a></code></pre></div>
 <p>So, here’s an example of a function with pattern matching and a default case that actually uses the value (instead of just ignoring it with <code>_</code>):</p>
-<div class="sourceCode" id="cb62"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb62-1" data-line-number="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb62-2" data-line-number="2">describe <span class="dv">0</span> <span class="fu">=</span> <span class="st">&quot;zero&quot;</span></a>
-<a class="sourceLine" id="cb62-3" data-line-number="3">describe <span class="dv">1</span> <span class="fu">=</span> <span class="st">&quot;one&quot;</span></a>
-<a class="sourceLine" id="cb62-4" data-line-number="4">describe <span class="dv">2</span> <span class="fu">=</span> <span class="st">&quot;an even prime&quot;</span></a>
-<a class="sourceLine" id="cb62-5" data-line-number="5">describe n <span class="fu">=</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> show n</a></code></pre></div>
+<div class="sourceCode" id="cb62"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb62-1" title="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb62-2" title="2">describe <span class="dv">0</span> <span class="fu">=</span> <span class="st">&quot;zero&quot;</span></a>
+<a class="sourceLine" id="cb62-3" title="3">describe <span class="dv">1</span> <span class="fu">=</span> <span class="st">&quot;one&quot;</span></a>
+<a class="sourceLine" id="cb62-4" title="4">describe <span class="dv">2</span> <span class="fu">=</span> <span class="st">&quot;an even prime&quot;</span></a>
+<a class="sourceLine" id="cb62-5" title="5">describe n <span class="fu">=</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> <span class="fu">show</span> n</a></code></pre></div>
 <p>This is how it works:</p>
-<div class="sourceCode" id="cb63"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb63-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">0</span></a>
-<a class="sourceLine" id="cb63-2" data-line-number="2"><span class="st">&quot;zero&quot;</span></a>
-<a class="sourceLine" id="cb63-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">2</span></a>
-<a class="sourceLine" id="cb63-4" data-line-number="4"><span class="st">&quot;an even prime&quot;</span></a>
-<a class="sourceLine" id="cb63-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">7</span></a>
-<a class="sourceLine" id="cb63-6" data-line-number="6"><span class="st">&quot;the number 7&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb63"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb63-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">0</span></a>
+<a class="sourceLine" id="cb63-2" title="2"><span class="st">&quot;zero&quot;</span></a>
+<a class="sourceLine" id="cb63-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">2</span></a>
+<a class="sourceLine" id="cb63-4" title="4"><span class="st">&quot;an even prime&quot;</span></a>
+<a class="sourceLine" id="cb63-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> describe <span class="dv">7</span></a>
+<a class="sourceLine" id="cb63-6" title="6"><span class="st">&quot;the number 7&quot;</span></a></code></pre></div>
 <p>You can even pattern match on multiple arguments. Again, the equations are tried in order. Here’s a reimplementation of the <code>login</code> function from earlier:</p>
-<div class="sourceCode" id="cb64"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb64-1" data-line-number="1"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb64-2" data-line-number="2">login <span class="st">&quot;unicorn73&quot;</span> <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="st">&quot;unicorn73 logged in&quot;</span></a>
-<a class="sourceLine" id="cb64-3" data-line-number="3">login <span class="st">&quot;unicorn73&quot;</span> _           <span class="fu">=</span> <span class="st">&quot;wrong password&quot;</span></a>
-<a class="sourceLine" id="cb64-4" data-line-number="4">login _           _           <span class="fu">=</span> <span class="st">&quot;unknown user&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb64"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb64-1" title="1"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb64-2" title="2">login <span class="st">&quot;unicorn73&quot;</span> <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="st">&quot;unicorn73 logged in&quot;</span></a>
+<a class="sourceLine" id="cb64-3" title="3">login <span class="st">&quot;unicorn73&quot;</span> _           <span class="fu">=</span> <span class="st">&quot;wrong password&quot;</span></a>
+<a class="sourceLine" id="cb64-4" title="4">login _           _           <span class="fu">=</span> <span class="st">&quot;unknown user&quot;</span></a></code></pre></div>
 <h3 id="recursion"><span class="header-section-number">1.9.5</span> Recursion</h3>
 <p>In Haskell, all sorts of loops are implemented with recursion. Function calls are very efficient, so you don’t need to worry about performance. (We’ll talk about performance later).</p>
 <p>Learning how to do simple things with recursion in Haskell will help you use recursion on more complex problems later. Recursion is also often a useful way for thinking about solving harder problems.</p>
@@ -760,39 +758,39 @@ Prelude&gt; polynomial 3.0
 <p><em>n! = n * (n-1) * … * 1</em></p>
 </blockquote>
 <p>For example, <em>4! = 4*3*2*1 = 24</em>. Well anyway, here’s the Haskell implementation of factorial:</p>
-<div class="sourceCode" id="cb65"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb65-1" data-line-number="1"><span class="ot">factorial ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb65-2" data-line-number="2">factorial <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb65-3" data-line-number="3">factorial n <span class="fu">=</span> n <span class="fu">*</span> factorial (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb65"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb65-1" title="1"><span class="ot">factorial ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb65-2" title="2">factorial <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb65-3" title="3">factorial n <span class="fu">=</span> n <span class="fu">*</span> factorial (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>This is how it works. We use <code>==&gt;</code> to mean “evaluates to”.</p>
-<div class="sourceCode" id="cb66"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb66-1" data-line-number="1">factorial <span class="dv">3</span></a>
-<a class="sourceLine" id="cb66-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> factorial (<span class="dv">3</span><span class="fu">-</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb66-3" data-line-number="3">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> factorial <span class="dv">2</span></a>
-<a class="sourceLine" id="cb66-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> <span class="dv">2</span> <span class="fu">*</span> factorial <span class="dv">1</span></a>
-<a class="sourceLine" id="cb66-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> <span class="dv">2</span> <span class="fu">*</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb66-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb66"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb66-1" title="1">factorial <span class="dv">3</span></a>
+<a class="sourceLine" id="cb66-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> factorial (<span class="dv">3</span><span class="fu">-</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb66-3" title="3">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> factorial <span class="dv">2</span></a>
+<a class="sourceLine" id="cb66-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> <span class="dv">2</span> <span class="fu">*</span> factorial <span class="dv">1</span></a>
+<a class="sourceLine" id="cb66-5" title="5">  <span class="fu">==&gt;</span> <span class="dv">3</span> <span class="fu">*</span> <span class="dv">2</span> <span class="fu">*</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb66-6" title="6">  <span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
 <p>What happens when you evaluate <code>factorial (-1)</code>?</p>
 <p>Here’s another example:</p>
-<div class="sourceCode" id="cb67"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb67-1" data-line-number="1"><span class="co">-- compute the sum 1^2+2^2+3^2+...+n^2</span></a>
-<a class="sourceLine" id="cb67-2" data-line-number="2">squareSum <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb67-3" data-line-number="3">squareSum n <span class="fu">=</span> n<span class="fu">^</span><span class="dv">2</span> <span class="fu">+</span> squareSum (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb67"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb67-1" title="1"><span class="co">-- compute the sum 1^2+2^2+3^2+...+n^2</span></a>
+<a class="sourceLine" id="cb67-2" title="2">squareSum <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb67-3" title="3">squareSum n <span class="fu">=</span> n<span class="fu">^</span><span class="dv">2</span> <span class="fu">+</span> squareSum (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>A function can call itself recursively multiple times. As an example let’s consider the <em>Fibonacci sequence</em> from mathematics. The Fibonacci sequence is a sequence of integers with the following definition.</p>
 <blockquote>
 <p>The sequence starts with 1, 1. To get the next element of the sequence, sum the previous two elements of the sequence.</p>
 </blockquote>
 <p>The first elements of the Fibonacci sequence are 1, 1, 2, 3, 5, 8, 13 and so on. Here’s a function <code>fibonacci</code> which computes the <code>n</code>th element in the Fibonacci sequence. Note how it mirrors the mathematical definition.</p>
-<div class="sourceCode" id="cb68"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb68-1" data-line-number="1"><span class="co">-- Fibonacci numbers, slow version</span></a>
-<a class="sourceLine" id="cb68-2" data-line-number="2">fibonacci <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb68-3" data-line-number="3">fibonacci <span class="dv">2</span> <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb68-4" data-line-number="4">fibonacci n <span class="fu">=</span> fibonacci (n<span class="fu">-</span><span class="dv">2</span>) <span class="fu">+</span> fibonacci (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb68"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb68-1" title="1"><span class="co">-- Fibonacci numbers, slow version</span></a>
+<a class="sourceLine" id="cb68-2" title="2">fibonacci <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb68-3" title="3">fibonacci <span class="dv">2</span> <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb68-4" title="4">fibonacci n <span class="fu">=</span> fibonacci (n<span class="fu">-</span><span class="dv">2</span>) <span class="fu">+</span> fibonacci (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>Here’s how <code>fibonacci 5</code> evaluates:</p>
-<div class="sourceCode" id="cb69"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb69-1" data-line-number="1">fibonacci <span class="dv">5</span></a>
-<a class="sourceLine" id="cb69-2" data-line-number="2">  <span class="fu">==&gt;</span> fibonacci <span class="dv">3</span>                 <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
-<a class="sourceLine" id="cb69-3" data-line-number="3">  <span class="fu">==&gt;</span> (fibonacci <span class="dv">1</span> <span class="fu">+</span> fibonacci <span class="dv">2</span>) <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
-<a class="sourceLine" id="cb69-4" data-line-number="4">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
-<a class="sourceLine" id="cb69-5" data-line-number="5">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (fibonacci <span class="dv">2</span> <span class="fu">+</span> fibonacci <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb69-6" data-line-number="6">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (fibonacci <span class="dv">2</span> <span class="fu">+</span> (fibonacci <span class="dv">1</span> <span class="fu">+</span> fibonacci <span class="dv">2</span>))</a>
-<a class="sourceLine" id="cb69-7" data-line-number="7">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (    <span class="dv">1</span>       <span class="fu">+</span> (    <span class="dv">1</span>       <span class="fu">+</span>     <span class="dv">1</span>      ))</a>
-<a class="sourceLine" id="cb69-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dv">5</span></a></code></pre></div>
+<div class="sourceCode" id="cb69"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb69-1" title="1">fibonacci <span class="dv">5</span></a>
+<a class="sourceLine" id="cb69-2" title="2">  <span class="fu">==&gt;</span> fibonacci <span class="dv">3</span>                 <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
+<a class="sourceLine" id="cb69-3" title="3">  <span class="fu">==&gt;</span> (fibonacci <span class="dv">1</span> <span class="fu">+</span> fibonacci <span class="dv">2</span>) <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
+<a class="sourceLine" id="cb69-4" title="4">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> fibonacci <span class="dv">4</span></a>
+<a class="sourceLine" id="cb69-5" title="5">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (fibonacci <span class="dv">2</span> <span class="fu">+</span> fibonacci <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb69-6" title="6">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (fibonacci <span class="dv">2</span> <span class="fu">+</span> (fibonacci <span class="dv">1</span> <span class="fu">+</span> fibonacci <span class="dv">2</span>))</a>
+<a class="sourceLine" id="cb69-7" title="7">  <span class="fu">==&gt;</span> (    <span class="dv">1</span>       <span class="fu">+</span>       <span class="dv">1</span>    ) <span class="fu">+</span> (    <span class="dv">1</span>       <span class="fu">+</span> (    <span class="dv">1</span>       <span class="fu">+</span>     <span class="dv">1</span>      ))</a>
+<a class="sourceLine" id="cb69-8" title="8">  <span class="fu">==&gt;</span> <span class="dv">5</span></a></code></pre></div>
 <p>Note how <code>fibonacci 3</code> gets evaluated twice and <code>fibonacci 2</code> three times. This is not the most efficient implementation of the <code>fibonacci</code> function. We’ll get back to this in the next lecture. Another way to think about the evaluation of the fibonacci function is to visualize it as a tree (we abbreviate <code>fibonacci</code> as <code>fib</code>): <!-- There could be some animation or a clickable interactive element for
      cycling through these images: --></p>
 <p><img src="img/Fibonacci-step1.svg" /></p>
@@ -848,34 +846,34 @@ fib 5        ==>          |           |
 <li>if the number is odd, triple it and add one</li>
 </ul>
 <p>As an example, the Collatz sequence for 3 is: 3, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1 … As you can see, once the number reaches 1, it gets caught in a loop.</p>
-<div class="sourceCode" id="cb70"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb70-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Collatz</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb70-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb70-3" data-line-number="3"><span class="co">-- one step of the Collatz sequence</span></a>
-<a class="sourceLine" id="cb70-4" data-line-number="4"><span class="ot">step ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb70-5" data-line-number="5">step x <span class="fu">=</span> <span class="kw">if</span> even x <span class="kw">then</span> down <span class="kw">else</span> up</a>
-<a class="sourceLine" id="cb70-6" data-line-number="6">  <span class="kw">where</span> down <span class="fu">=</span> div x <span class="dv">2</span></a>
-<a class="sourceLine" id="cb70-7" data-line-number="7">        up <span class="fu">=</span> <span class="dv">3</span><span class="fu">*</span>x<span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb70-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb70-9" data-line-number="9"><span class="co">-- collatz x computes how many steps it takes for the Collatz sequence</span></a>
-<a class="sourceLine" id="cb70-10" data-line-number="10"><span class="co">-- to reach 1 when starting from x</span></a>
-<a class="sourceLine" id="cb70-11" data-line-number="11"><span class="ot">collatz ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb70-12" data-line-number="12">collatz <span class="dv">1</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb70-13" data-line-number="13">collatz x <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> collatz (step x)</a>
-<a class="sourceLine" id="cb70-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb70-15" data-line-number="15"><span class="co">-- longest finds the number with the longest Collatz sequence for initial values</span></a>
-<a class="sourceLine" id="cb70-16" data-line-number="16"><span class="co">-- between 0 and upperBound</span></a>
-<a class="sourceLine" id="cb70-17" data-line-number="17"><span class="ot">longest ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb70-18" data-line-number="18">longest upperBound <span class="fu">=</span> longest&#39; <span class="dv">0</span> <span class="dv">0</span> upperBound</a>
-<a class="sourceLine" id="cb70-19" data-line-number="19"></a>
-<a class="sourceLine" id="cb70-20" data-line-number="20"><span class="co">-- helper function for longest</span></a>
-<a class="sourceLine" id="cb70-21" data-line-number="21"><span class="ot">longest&#39; ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb70-22" data-line-number="22"><span class="co">-- end of recursion, return longest length found</span></a>
-<a class="sourceLine" id="cb70-23" data-line-number="23">longest&#39; number _ <span class="dv">0</span> <span class="fu">=</span> number</a>
-<a class="sourceLine" id="cb70-24" data-line-number="24"><span class="co">-- recursion step: check if n has a longer Collatz sequence than the current known longest</span></a>
-<a class="sourceLine" id="cb70-25" data-line-number="25">longest&#39; number maxlength n <span class="fu">=</span> <span class="kw">if</span> length <span class="fu">&gt;</span> maxlength</a>
-<a class="sourceLine" id="cb70-26" data-line-number="26">               <span class="kw">then</span> longest&#39; n length (n<span class="fu">-</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb70-27" data-line-number="27">               <span class="kw">else</span> longest&#39; number maxlength (n<span class="fu">-</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb70-28" data-line-number="28">  <span class="kw">where</span> length <span class="fu">=</span> collatz n</a></code></pre></div>
+<div class="sourceCode" id="cb70"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb70-1" title="1"><span class="kw">module</span> <span class="dt">Collatz</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb70-2" title="2"></a>
+<a class="sourceLine" id="cb70-3" title="3"><span class="co">-- one step of the Collatz sequence</span></a>
+<a class="sourceLine" id="cb70-4" title="4"><span class="ot">step ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb70-5" title="5">step x <span class="fu">=</span> <span class="kw">if</span> <span class="fu">even</span> x <span class="kw">then</span> down <span class="kw">else</span> up</a>
+<a class="sourceLine" id="cb70-6" title="6">  <span class="kw">where</span> down <span class="fu">=</span> <span class="fu">div</span> x <span class="dv">2</span></a>
+<a class="sourceLine" id="cb70-7" title="7">        up <span class="fu">=</span> <span class="dv">3</span><span class="fu">*</span>x<span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb70-8" title="8"></a>
+<a class="sourceLine" id="cb70-9" title="9"><span class="co">-- collatz x computes how many steps it takes for the Collatz sequence</span></a>
+<a class="sourceLine" id="cb70-10" title="10"><span class="co">-- to reach 1 when starting from x</span></a>
+<a class="sourceLine" id="cb70-11" title="11"><span class="ot">collatz ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb70-12" title="12">collatz <span class="dv">1</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb70-13" title="13">collatz x <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> collatz (step x)</a>
+<a class="sourceLine" id="cb70-14" title="14"></a>
+<a class="sourceLine" id="cb70-15" title="15"><span class="co">-- longest finds the number with the longest Collatz sequence for initial values</span></a>
+<a class="sourceLine" id="cb70-16" title="16"><span class="co">-- between 0 and upperBound</span></a>
+<a class="sourceLine" id="cb70-17" title="17"><span class="ot">longest ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb70-18" title="18">longest upperBound <span class="fu">=</span> longest&#39; <span class="dv">0</span> <span class="dv">0</span> upperBound</a>
+<a class="sourceLine" id="cb70-19" title="19"></a>
+<a class="sourceLine" id="cb70-20" title="20"><span class="co">-- helper function for longest</span></a>
+<a class="sourceLine" id="cb70-21" title="21"><span class="ot">longest&#39; ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb70-22" title="22"><span class="co">-- end of recursion, return longest length found</span></a>
+<a class="sourceLine" id="cb70-23" title="23">longest&#39; number _ <span class="dv">0</span> <span class="fu">=</span> number</a>
+<a class="sourceLine" id="cb70-24" title="24"><span class="co">-- recursion step: check if n has a longer Collatz sequence than the current known longest</span></a>
+<a class="sourceLine" id="cb70-25" title="25">longest&#39; number maxlength n <span class="fu">=</span> <span class="kw">if</span> <span class="fu">length</span> <span class="fu">&gt;</span> maxlength</a>
+<a class="sourceLine" id="cb70-26" title="26">               <span class="kw">then</span> longest&#39; n <span class="fu">length</span> (n<span class="fu">-</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb70-27" title="27">               <span class="kw">else</span> longest&#39; number maxlength (n<span class="fu">-</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb70-28" title="28">  <span class="kw">where</span> <span class="fu">length</span> <span class="fu">=</span> collatz n</a></code></pre></div>
 <p>We can load the program in GHCi and play with it.</p>
 <pre><code>$ stack ghci
 GHCi, version 8.2.2: http://www.haskell.org/ghc/  :? for help
@@ -912,48 +910,48 @@ Ok, one module loaded.
 <p>While you can get away with using tabs, it is highly recommended to use spaces for all indenting.</p>
 <p>Some examples are in order.</p>
 <p>These all are ok:</p>
-<div class="sourceCode" id="cb76"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb76-1" data-line-number="1">i x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x <span class="kw">in</span> div y <span class="dv">5</span></a>
-<a class="sourceLine" id="cb76-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb76-3" data-line-number="3"><span class="co">-- let and in are grouped together, an expression is split</span></a>
-<a class="sourceLine" id="cb76-4" data-line-number="4">j x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb76-5" data-line-number="5">              <span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb76-6" data-line-number="6">      <span class="kw">in</span> div y <span class="dv">5</span></a>
-<a class="sourceLine" id="cb76-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb76-8" data-line-number="8"><span class="co">-- the definitions of a and b are grouped together</span></a>
-<a class="sourceLine" id="cb76-9" data-line-number="9">k <span class="fu">=</span> a <span class="fu">+</span> b</a>
-<a class="sourceLine" id="cb76-10" data-line-number="10">  <span class="kw">where</span> a <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb76-11" data-line-number="11">        b <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb76-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb76-13" data-line-number="13">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
-<a class="sourceLine" id="cb76-14" data-line-number="14">  <span class="kw">where</span></a>
-<a class="sourceLine" id="cb76-15" data-line-number="15">    a <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb76-16" data-line-number="16">    b <span class="fu">=</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb76"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb76-1" title="1">i x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x <span class="kw">in</span> <span class="fu">div</span> y <span class="dv">5</span></a>
+<a class="sourceLine" id="cb76-2" title="2"></a>
+<a class="sourceLine" id="cb76-3" title="3"><span class="co">-- let and in are grouped together, an expression is split</span></a>
+<a class="sourceLine" id="cb76-4" title="4">j x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb76-5" title="5">              <span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb76-6" title="6">      <span class="kw">in</span> <span class="fu">div</span> y <span class="dv">5</span></a>
+<a class="sourceLine" id="cb76-7" title="7"></a>
+<a class="sourceLine" id="cb76-8" title="8"><span class="co">-- the definitions of a and b are grouped together</span></a>
+<a class="sourceLine" id="cb76-9" title="9">k <span class="fu">=</span> a <span class="fu">+</span> b</a>
+<a class="sourceLine" id="cb76-10" title="10">  <span class="kw">where</span> a <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb76-11" title="11">        b <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb76-12" title="12"></a>
+<a class="sourceLine" id="cb76-13" title="13">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
+<a class="sourceLine" id="cb76-14" title="14">  <span class="kw">where</span></a>
+<a class="sourceLine" id="cb76-15" title="15">    a <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb76-16" title="16">    b <span class="fu">=</span> <span class="dv">1</span></a></code></pre></div>
 <p>These are not ok:</p>
-<div class="sourceCode" id="cb77"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb77-1" data-line-number="1"><span class="co">-- indentation not increased even though expression split on many lines</span></a>
-<a class="sourceLine" id="cb77-2" data-line-number="2">i x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb77-3" data-line-number="3"><span class="kw">in</span> div y <span class="dv">5</span></a>
-<a class="sourceLine" id="cb77-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb77-5" data-line-number="5"><span class="co">-- indentation not increased even though expression is split</span></a>
-<a class="sourceLine" id="cb77-6" data-line-number="6">j x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb77-7" data-line-number="7">      <span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb77-8" data-line-number="8">      <span class="kw">in</span> div y <span class="dv">5</span></a>
-<a class="sourceLine" id="cb77-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb77-10" data-line-number="10"><span class="co">-- grouped things are not aligned</span></a>
-<a class="sourceLine" id="cb77-11" data-line-number="11">k <span class="fu">=</span> a <span class="fu">+</span> b</a>
-<a class="sourceLine" id="cb77-12" data-line-number="12">  <span class="kw">where</span> a <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-13" data-line-number="13">      b <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb77-15" data-line-number="15"><span class="co">-- grouped things are not aligned</span></a>
-<a class="sourceLine" id="cb77-16" data-line-number="16">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
-<a class="sourceLine" id="cb77-17" data-line-number="17">  <span class="kw">where</span></a>
-<a class="sourceLine" id="cb77-18" data-line-number="18">    a <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-19" data-line-number="19">     b <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-20" data-line-number="20"></a>
-<a class="sourceLine" id="cb77-21" data-line-number="21"><span class="co">-- where is part of the equation, so indentation needs to increase</span></a>
-<a class="sourceLine" id="cb77-22" data-line-number="22">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
-<a class="sourceLine" id="cb77-23" data-line-number="23"><span class="kw">where</span></a>
-<a class="sourceLine" id="cb77-24" data-line-number="24">  a <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-25" data-line-number="25">  b <span class="fu">=</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb77"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb77-1" title="1"><span class="co">-- indentation not increased even though expression split on many lines</span></a>
+<a class="sourceLine" id="cb77-2" title="2">i x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb77-3" title="3"><span class="kw">in</span> <span class="fu">div</span> y <span class="dv">5</span></a>
+<a class="sourceLine" id="cb77-4" title="4"></a>
+<a class="sourceLine" id="cb77-5" title="5"><span class="co">-- indentation not increased even though expression is split</span></a>
+<a class="sourceLine" id="cb77-6" title="6">j x <span class="fu">=</span> <span class="kw">let</span> y <span class="fu">=</span> x<span class="fu">+</span>x<span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb77-7" title="7">      <span class="fu">+</span>x<span class="fu">+</span>x<span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb77-8" title="8">      <span class="kw">in</span> <span class="fu">div</span> y <span class="dv">5</span></a>
+<a class="sourceLine" id="cb77-9" title="9"></a>
+<a class="sourceLine" id="cb77-10" title="10"><span class="co">-- grouped things are not aligned</span></a>
+<a class="sourceLine" id="cb77-11" title="11">k <span class="fu">=</span> a <span class="fu">+</span> b</a>
+<a class="sourceLine" id="cb77-12" title="12">  <span class="kw">where</span> a <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-13" title="13">      b <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-14" title="14"></a>
+<a class="sourceLine" id="cb77-15" title="15"><span class="co">-- grouped things are not aligned</span></a>
+<a class="sourceLine" id="cb77-16" title="16">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
+<a class="sourceLine" id="cb77-17" title="17">  <span class="kw">where</span></a>
+<a class="sourceLine" id="cb77-18" title="18">    a <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-19" title="19">     b <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-20" title="20"></a>
+<a class="sourceLine" id="cb77-21" title="21"><span class="co">-- where is part of the equation, so indentation needs to increase</span></a>
+<a class="sourceLine" id="cb77-22" title="22">l <span class="fu">=</span> a <span class="fu">+</span> b</a>
+<a class="sourceLine" id="cb77-23" title="23"><span class="kw">where</span></a>
+<a class="sourceLine" id="cb77-24" title="24">  a <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-25" title="25">  b <span class="fu">=</span> <span class="dv">1</span></a></code></pre></div>
 <p>If you make a mistake with the indentation, you’ll typically get a parse error like this:</p>
 <pre><code>Indent.hs:2:1: error: parse error on input ‘where’</code></pre>
 <p>The error includes the line number, so just go over that line again. If you can’t seem to get indentation to work, try putting everything on just one long line at first.</p>
@@ -1049,11 +1047,11 @@ Because <code>`...`</code> is used for delimiting strings.
 <h2 id="working-on-the-exercises"><span class="header-section-number">1.13</span> Working on the Exercises</h2>
 <p>The course materials, including exercises, are available in a Git repository on GitHub at <a href="https://github.com/moocfi/haskell-mooc" class="uri">https://github.com/moocfi/haskell-mooc</a>. If you’re not familiar with Git, see <a href="https://help.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository">GitHub’s instructions on cloning a repository</a>.</p>
 <p>Once you’ve cloned the <code>haskell-mooc</code> repository, go into the <code>exercises</code> directory. To download and build dependencies needed for running the exercise tests (such as the correct version of GHC and various libraries), run following command in your terminal:</p>
-<div class="sourceCode" id="cb79"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb79-1" data-line-number="1">$ <span class="ex">stack</span> build</a></code></pre></div>
+<div class="sourceCode" id="cb79"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb79-1" title="1">$ <span class="ex">stack</span> build</a></code></pre></div>
 <p>Do note that the dependencies are multiple gigabytes and it will take a while for the command to finish.</p>
 <p>There are primarily two types of files in the <code>exercises</code> directory: exercise sets named <code>SetNX.hs</code> and accompanying test program for the exercises named <code>SetNXTest.hs</code>. Both are Haskell source files, but only the exercise file should to be edited when solving the exercises. Instructions to all individual exercises are embedded in the exercise file as comments.</p>
 <p>Use the tests file to check your answers. For example when you have solved some of the exercises in <code>Set1.hs</code>, run the following command:</p>
-<div class="sourceCode" id="cb80"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb80-1" data-line-number="1">$ <span class="ex">stack</span> runhaskell Set1Test.hs</a></code></pre></div>
+<div class="sourceCode" id="cb80"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb80-1" title="1">$ <span class="ex">stack</span> runhaskell Set1Test.hs</a></code></pre></div>
 <p>The output of the tests looks something like this:</p>
 <pre><code>===== EXERCISE 1
 +++++ Pass
@@ -1113,8 +1111,8 @@ Ok, two modules loaded.
 <p>Once you’re done with an exercise set, you can turn it in on the <a href="https://haskell.mooc.fi/submit.php">Submit page</a> on the course pages. After that you can see the results of your submission on the <a href="https://haskell.mooc.fi/results.php">Results page</a> and your total score on the <a href="https://haskell.mooc.fi/status.php">My status page</a>.</p>
 <p><strong>Note!</strong> You may turn in an exercise set as many times as you want.</p>
 <p><strong>Note!</strong> If you don’t want to use Stack or can’t get it working, you should also be able to run the tests with <a href="https://www.haskell.org/cabal/download.html">Cabal</a> like this:</p>
-<div class="sourceCode" id="cb83"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb83-1" data-line-number="1">$ <span class="ex">cabal</span> v2-build</a>
-<a class="sourceLine" id="cb83-2" data-line-number="2">$ <span class="ex">cabal</span> v2-exec runhaskell Set1Test.hs</a></code></pre></div>
+<div class="sourceCode" id="cb83"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb83-1" title="1">$ <span class="ex">cabal</span> v2-build</a>
+<a class="sourceLine" id="cb83-2" title="2">$ <span class="ex">cabal</span> v2-exec runhaskell Set1Test.hs</a></code></pre></div>
 <h3 id="model-solutions"><span class="header-section-number">1.13.1</span> Model Solutions</h3>
 <p>Once you’ve successfully completed all the exercises in a set, you can view the model solutions on the <a href="https://haskell.mooc.fi/status">My status page</a>. It’s useful to glance at the model solutions, they might show you a technique you’ve missed!</p>
 <h2 id="exercises"><span class="header-section-number">1.14</span> Exercises</h2>
@@ -1132,66 +1130,66 @@ Ok, two modules loaded.
 <p>Often you’ll find you need helper variables in recursion to keep track of things. You can get them by defining a helper function with more arguments. Analogy: arguments of the helper function are variables you update in your loop.</p>
 <p>Here’s an example of how you would convert a loop (in Java or Python) into a recursive helper function in Haskell.</p>
 <p>Java:</p>
-<div class="sourceCode" id="cb84"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb84-1" data-line-number="1"><span class="kw">public</span> <span class="bu">String</span> <span class="fu">repeatString</span>(<span class="dt">int</span> n, <span class="bu">String</span> str) {</a>
-<a class="sourceLine" id="cb84-2" data-line-number="2">    <span class="bu">String</span> result = <span class="st">&quot;&quot;</span>;</a>
-<a class="sourceLine" id="cb84-3" data-line-number="3">    <span class="kw">while</span> (n&gt;<span class="dv">0</span>) {</a>
-<a class="sourceLine" id="cb84-4" data-line-number="4">        result = result+str;</a>
-<a class="sourceLine" id="cb84-5" data-line-number="5">        n = n<span class="dv">-1</span>;</a>
-<a class="sourceLine" id="cb84-6" data-line-number="6">    }</a>
-<a class="sourceLine" id="cb84-7" data-line-number="7">    <span class="kw">return</span> result;</a>
-<a class="sourceLine" id="cb84-8" data-line-number="8">}</a></code></pre></div>
+<div class="sourceCode" id="cb84"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb84-1" title="1"><span class="kw">public</span> <span class="bu">String</span> <span class="fu">repeatString</span>(<span class="dt">int</span> n, <span class="bu">String</span> str) {</a>
+<a class="sourceLine" id="cb84-2" title="2">    <span class="bu">String</span> result = <span class="st">&quot;&quot;</span>;</a>
+<a class="sourceLine" id="cb84-3" title="3">    <span class="kw">while</span> (n&gt;<span class="dv">0</span>) {</a>
+<a class="sourceLine" id="cb84-4" title="4">        result = result+str;</a>
+<a class="sourceLine" id="cb84-5" title="5">        n = n-<span class="dv">1</span>;</a>
+<a class="sourceLine" id="cb84-6" title="6">    }</a>
+<a class="sourceLine" id="cb84-7" title="7">    <span class="kw">return</span> result;</a>
+<a class="sourceLine" id="cb84-8" title="8">}</a></code></pre></div>
 <p>Python:</p>
-<div class="sourceCode" id="cb85"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb85-1" data-line-number="1"><span class="kw">def</span> repeatString(n, <span class="bu">str</span>):</a>
-<a class="sourceLine" id="cb85-2" data-line-number="2">    result <span class="op">=</span> <span class="st">&quot;&quot;</span></a>
-<a class="sourceLine" id="cb85-3" data-line-number="3">    <span class="cf">while</span> n<span class="op">&gt;</span><span class="dv">0</span>:</a>
-<a class="sourceLine" id="cb85-4" data-line-number="4">        result <span class="op">=</span> result<span class="op">+</span><span class="bu">str</span></a>
-<a class="sourceLine" id="cb85-5" data-line-number="5">        n <span class="op">=</span> n<span class="dv">-1</span></a>
-<a class="sourceLine" id="cb85-6" data-line-number="6">    <span class="cf">return</span> result</a></code></pre></div>
+<div class="sourceCode" id="cb85"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb85-1" title="1"><span class="kw">def</span> repeatString(n, <span class="bu">str</span>):</a>
+<a class="sourceLine" id="cb85-2" title="2">    result <span class="op">=</span> <span class="st">&quot;&quot;</span></a>
+<a class="sourceLine" id="cb85-3" title="3">    <span class="cf">while</span> n<span class="op">&gt;</span><span class="dv">0</span>:</a>
+<a class="sourceLine" id="cb85-4" title="4">        result <span class="op">=</span> result<span class="op">+</span><span class="bu">str</span></a>
+<a class="sourceLine" id="cb85-5" title="5">        n <span class="op">=</span> n<span class="dv">-1</span></a>
+<a class="sourceLine" id="cb85-6" title="6">    <span class="cf">return</span> result</a></code></pre></div>
 <p>Haskell:</p>
-<div class="sourceCode" id="cb86"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb86-1" data-line-number="1">repeatString n str <span class="fu">=</span> repeatHelper n str <span class="st">&quot;&quot;</span></a>
-<a class="sourceLine" id="cb86-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb86-3" data-line-number="3">repeatHelper n str result <span class="fu">=</span> <span class="kw">if</span> (n<span class="fu">==</span><span class="dv">0</span>)</a>
-<a class="sourceLine" id="cb86-4" data-line-number="4">                            <span class="kw">then</span> result</a>
-<a class="sourceLine" id="cb86-5" data-line-number="5">                            <span class="kw">else</span> repeatHelper (n<span class="fu">-</span><span class="dv">1</span>) str (result<span class="fu">++</span>str)</a></code></pre></div>
-<div class="sourceCode" id="cb87"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb87-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> repeatString <span class="dv">3</span> <span class="st">&quot;ABC&quot;</span></a>
-<a class="sourceLine" id="cb87-2" data-line-number="2"><span class="st">&quot;ABCABCABC&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb86"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb86-1" title="1">repeatString n str <span class="fu">=</span> repeatHelper n str <span class="st">&quot;&quot;</span></a>
+<a class="sourceLine" id="cb86-2" title="2"></a>
+<a class="sourceLine" id="cb86-3" title="3">repeatHelper n str result <span class="fu">=</span> <span class="kw">if</span> (n<span class="fu">==</span><span class="dv">0</span>)</a>
+<a class="sourceLine" id="cb86-4" title="4">                            <span class="kw">then</span> result</a>
+<a class="sourceLine" id="cb86-5" title="5">                            <span class="kw">else</span> repeatHelper (n<span class="fu">-</span><span class="dv">1</span>) str (result<span class="fu">++</span>str)</a></code></pre></div>
+<div class="sourceCode" id="cb87"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb87-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> repeatString <span class="dv">3</span> <span class="st">&quot;ABC&quot;</span></a>
+<a class="sourceLine" id="cb87-2" title="2"><span class="st">&quot;ABCABCABC&quot;</span></a></code></pre></div>
 <p>You might have noticed that the Java and Python implementations look a bit weird since they use while loops instead of for loops. This is because this way the conversion to Haskell is more straightforward.</p>
 <p>This can be made a bit tidier by using pattern matching instead of an <code>if</code>:</p>
-<div class="sourceCode" id="cb88"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb88-1" data-line-number="1">repeatString n str <span class="fu">=</span> repeatHelper n str <span class="st">&quot;&quot;</span></a>
-<a class="sourceLine" id="cb88-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb88-3" data-line-number="3">repeatHelper <span class="dv">0</span> _   result <span class="fu">=</span> result</a>
-<a class="sourceLine" id="cb88-4" data-line-number="4">repeatHelper n str result <span class="fu">=</span> repeatHelper (n<span class="fu">-</span><span class="dv">1</span>) str (result<span class="fu">++</span>str)</a></code></pre></div>
+<div class="sourceCode" id="cb88"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb88-1" title="1">repeatString n str <span class="fu">=</span> repeatHelper n str <span class="st">&quot;&quot;</span></a>
+<a class="sourceLine" id="cb88-2" title="2"></a>
+<a class="sourceLine" id="cb88-3" title="3">repeatHelper <span class="dv">0</span> _   result <span class="fu">=</span> result</a>
+<a class="sourceLine" id="cb88-4" title="4">repeatHelper n str result <span class="fu">=</span> repeatHelper (n<span class="fu">-</span><span class="dv">1</span>) str (result<span class="fu">++</span>str)</a></code></pre></div>
 <p>Here’s another example with more variables: computing fibonacci numbers efficiently.</p>
 <p>Java:</p>
-<div class="sourceCode" id="cb89"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb89-1" data-line-number="1"><span class="kw">public</span> <span class="dt">int</span> <span class="fu">fibonacci</span>(<span class="dt">int</span> n) {</a>
-<a class="sourceLine" id="cb89-2" data-line-number="2">    <span class="dt">int</span> a = <span class="dv">0</span>;</a>
-<a class="sourceLine" id="cb89-3" data-line-number="3">    <span class="dt">int</span> b = <span class="dv">1</span>;</a>
-<a class="sourceLine" id="cb89-4" data-line-number="4">    <span class="kw">while</span> (n&gt;<span class="dv">1</span>) {</a>
-<a class="sourceLine" id="cb89-5" data-line-number="5">        <span class="dt">int</span> c = a+b;</a>
-<a class="sourceLine" id="cb89-6" data-line-number="6">        a=b;</a>
-<a class="sourceLine" id="cb89-7" data-line-number="7">        b=c;</a>
-<a class="sourceLine" id="cb89-8" data-line-number="8">        n--;</a>
-<a class="sourceLine" id="cb89-9" data-line-number="9">    }</a>
-<a class="sourceLine" id="cb89-10" data-line-number="10">    <span class="kw">return</span> b;</a>
-<a class="sourceLine" id="cb89-11" data-line-number="11">}</a></code></pre></div>
+<div class="sourceCode" id="cb89"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb89-1" title="1"><span class="kw">public</span> <span class="dt">int</span> <span class="fu">fibonacci</span>(<span class="dt">int</span> n) {</a>
+<a class="sourceLine" id="cb89-2" title="2">    <span class="dt">int</span> a = <span class="dv">0</span>;</a>
+<a class="sourceLine" id="cb89-3" title="3">    <span class="dt">int</span> b = <span class="dv">1</span>;</a>
+<a class="sourceLine" id="cb89-4" title="4">    <span class="kw">while</span> (n&gt;<span class="dv">1</span>) {</a>
+<a class="sourceLine" id="cb89-5" title="5">        <span class="dt">int</span> c = a+b;</a>
+<a class="sourceLine" id="cb89-6" title="6">        a=b;</a>
+<a class="sourceLine" id="cb89-7" title="7">        b=c;</a>
+<a class="sourceLine" id="cb89-8" title="8">        n--;</a>
+<a class="sourceLine" id="cb89-9" title="9">    }</a>
+<a class="sourceLine" id="cb89-10" title="10">    <span class="kw">return</span> b;</a>
+<a class="sourceLine" id="cb89-11" title="11">}</a></code></pre></div>
 <p>Python:</p>
-<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb90-1" data-line-number="1"><span class="kw">def</span> fibonacci(n):</a>
-<a class="sourceLine" id="cb90-2" data-line-number="2">    a <span class="op">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb90-3" data-line-number="3">    b <span class="op">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb90-4" data-line-number="4">    <span class="cf">while</span> n<span class="op">&gt;</span><span class="dv">1</span>:</a>
-<a class="sourceLine" id="cb90-5" data-line-number="5">        c <span class="op">=</span> a<span class="op">+</span>b</a>
-<a class="sourceLine" id="cb90-6" data-line-number="6">        a <span class="op">=</span> b</a>
-<a class="sourceLine" id="cb90-7" data-line-number="7">        b <span class="op">=</span> c</a>
-<a class="sourceLine" id="cb90-8" data-line-number="8">        n <span class="op">=</span> n<span class="dv">-1</span></a>
-<a class="sourceLine" id="cb90-9" data-line-number="9">    <span class="cf">return</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb90-1" title="1"><span class="kw">def</span> fibonacci(n):</a>
+<a class="sourceLine" id="cb90-2" title="2">    a <span class="op">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb90-3" title="3">    b <span class="op">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb90-4" title="4">    <span class="cf">while</span> n<span class="op">&gt;</span><span class="dv">1</span>:</a>
+<a class="sourceLine" id="cb90-5" title="5">        c <span class="op">=</span> a<span class="op">+</span>b</a>
+<a class="sourceLine" id="cb90-6" title="6">        a <span class="op">=</span> b</a>
+<a class="sourceLine" id="cb90-7" title="7">        b <span class="op">=</span> c</a>
+<a class="sourceLine" id="cb90-8" title="8">        n <span class="op">=</span> n<span class="dv">-1</span></a>
+<a class="sourceLine" id="cb90-9" title="9">    <span class="cf">return</span> b</a></code></pre></div>
 <p>Haskell:</p>
-<div class="sourceCode" id="cb91"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb91-1" data-line-number="1"><span class="co">-- fibonacci numbers, fast version</span></a>
-<a class="sourceLine" id="cb91-2" data-line-number="2"><span class="ot">fibonacci ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb91-3" data-line-number="3">fibonacci n <span class="fu">=</span> fibonacci&#39; <span class="dv">0</span> <span class="dv">1</span> n</a>
-<a class="sourceLine" id="cb91-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb91-5" data-line-number="5"><span class="ot">fibonacci&#39; ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb91-6" data-line-number="6">fibonacci&#39; a b <span class="dv">1</span> <span class="fu">=</span> b</a>
-<a class="sourceLine" id="cb91-7" data-line-number="7">fibonacci&#39; a b n <span class="fu">=</span> fibonacci&#39; b (a<span class="fu">+</span>b) (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb91"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb91-1" title="1"><span class="co">-- fibonacci numbers, fast version</span></a>
+<a class="sourceLine" id="cb91-2" title="2"><span class="ot">fibonacci ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb91-3" title="3">fibonacci n <span class="fu">=</span> fibonacci&#39; <span class="dv">0</span> <span class="dv">1</span> n</a>
+<a class="sourceLine" id="cb91-4" title="4"></a>
+<a class="sourceLine" id="cb91-5" title="5"><span class="ot">fibonacci&#39; ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb91-6" title="6">fibonacci&#39; a b <span class="dv">1</span> <span class="fu">=</span> b</a>
+<a class="sourceLine" id="cb91-7" title="7">fibonacci&#39; a b n <span class="fu">=</span> fibonacci&#39; b (a<span class="fu">+</span>b) (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>Take a while to study these and note how the Haskell recursion has the same format as the loop.</p>
 <p>Sidenote: Haskell programs often use the apostrophe to name helper functions and alternative versions of functions. Thus the name <code>fibonacci'</code> for the helper function above. Names like <code>foo'</code> are usually read <em>foo prime</em> (like in mathematics).</p>
 <p>I said earlier that this version of fibonacci is more efficient. Can you see why? The answer is that there are less recursive calls. The expression <code>fibonacci' _ _ n</code> calls <code>fibonacci' _ _ (n-1)</code> once, and this means that we can compute <code>fibonacci' _ _ n</code> in <code>n</code> steps.</p>
@@ -1199,116 +1197,116 @@ Ok, two modules loaded.
 <h2 id="guards"><span class="header-section-number">2.2</span> Guards</h2>
 <p>Before we move on to new types, let’s go over one more piece of Haskell syntax.</p>
 <p>The <code>if then else</code> is often a bit cumbersome, especially when you have multiple cases. An easier alternative is Haskell’s <em>conditional definition</em> or <em>guarded definition</em>. This is a bit like pattern matching in that you have multiple equations, but you can have arbitrary code deciding which equation to use. Guarded definitions look like this:</p>
-<div class="sourceCode" id="cb92"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb92-1" data-line-number="1">f x y z</a>
-<a class="sourceLine" id="cb92-2" data-line-number="2">  <span class="fu">|</span> condition1 <span class="fu">=</span> something</a>
-<a class="sourceLine" id="cb92-3" data-line-number="3">  <span class="fu">|</span> condition2 <span class="fu">=</span> other</a>
-<a class="sourceLine" id="cb92-4" data-line-number="4">  <span class="fu">|</span> otherwise  <span class="fu">=</span> somethingother</a></code></pre></div>
+<div class="sourceCode" id="cb92"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb92-1" title="1">f x y z</a>
+<a class="sourceLine" id="cb92-2" title="2">  <span class="fu">|</span> condition1 <span class="fu">=</span> something</a>
+<a class="sourceLine" id="cb92-3" title="3">  <span class="fu">|</span> condition2 <span class="fu">=</span> other</a>
+<a class="sourceLine" id="cb92-4" title="4">  <span class="fu">|</span> <span class="fu">otherwise</span>  <span class="fu">=</span> somethingother</a></code></pre></div>
 <p>A condition can be any expression of type <code>Bool</code>. The first condition that evaluates to <code>True</code> is chosen. The word <code>otherwise</code> is just an alias for <code>True</code>. It is used to mark the default case.</p>
 <h3 id="examples-1"><span class="header-section-number">2.2.1</span> Examples</h3>
 <p>Here are some examples of using guards. First off, we have a function that describes the given number. Note how it is important to have the <code>&quot;Two&quot;</code> case before the <code>&quot;Even&quot;</code> case.</p>
-<div class="sourceCode" id="cb93"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb93-1" data-line-number="1"><span class="ot">describe ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb93-2" data-line-number="2">describe n</a>
-<a class="sourceLine" id="cb93-3" data-line-number="3">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">2</span>      <span class="fu">=</span> <span class="st">&quot;Two&quot;</span></a>
-<a class="sourceLine" id="cb93-4" data-line-number="4">  <span class="fu">|</span> even n    <span class="fu">=</span> <span class="st">&quot;Even&quot;</span></a>
-<a class="sourceLine" id="cb93-5" data-line-number="5">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">3</span>      <span class="fu">=</span> <span class="st">&quot;Three&quot;</span></a>
-<a class="sourceLine" id="cb93-6" data-line-number="6">  <span class="fu">|</span> n<span class="fu">&gt;</span><span class="dv">100</span>     <span class="fu">=</span> <span class="st">&quot;Big!!&quot;</span></a>
-<a class="sourceLine" id="cb93-7" data-line-number="7">  <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="st">&quot;The number &quot;</span><span class="fu">++</span>show n</a></code></pre></div>
+<div class="sourceCode" id="cb93"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb93-1" title="1"><span class="ot">describe ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb93-2" title="2">describe n</a>
+<a class="sourceLine" id="cb93-3" title="3">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">2</span>      <span class="fu">=</span> <span class="st">&quot;Two&quot;</span></a>
+<a class="sourceLine" id="cb93-4" title="4">  <span class="fu">|</span> <span class="fu">even</span> n    <span class="fu">=</span> <span class="st">&quot;Even&quot;</span></a>
+<a class="sourceLine" id="cb93-5" title="5">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">3</span>      <span class="fu">=</span> <span class="st">&quot;Three&quot;</span></a>
+<a class="sourceLine" id="cb93-6" title="6">  <span class="fu">|</span> n<span class="fu">&gt;</span><span class="dv">100</span>     <span class="fu">=</span> <span class="st">&quot;Big!!&quot;</span></a>
+<a class="sourceLine" id="cb93-7" title="7">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="st">&quot;The number &quot;</span><span class="fu">++show</span> n</a></code></pre></div>
 <p>Here is factorial, implemented with guards instead of pattern matching. Unlike the pattern-matching version, this one doesn’t loop forever with negative inputs.</p>
-<div class="sourceCode" id="cb94"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb94-1" data-line-number="1">factorial n</a>
-<a class="sourceLine" id="cb94-2" data-line-number="2">  <span class="fu">|</span> n<span class="fu">&lt;</span><span class="dv">0</span>       <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb94-3" data-line-number="3">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">0</span>      <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb94-4" data-line-number="4">  <span class="fu">|</span> otherwise <span class="fu">=</span> n <span class="fu">*</span> factorial (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb94"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb94-1" title="1">factorial n</a>
+<a class="sourceLine" id="cb94-2" title="2">  <span class="fu">|</span> n<span class="fu">&lt;</span><span class="dv">0</span>       <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb94-3" title="3">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">0</span>      <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb94-4" title="4">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> n <span class="fu">*</span> factorial (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>You can even combine guards with pattern matching. Here’s the implementation of a simple age guessing game:</p>
-<div class="sourceCode" id="cb95"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb95-1" data-line-number="1"><span class="ot">guessAge ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb95-2" data-line-number="2">guessAge <span class="st">&quot;Griselda&quot;</span> age</a>
-<a class="sourceLine" id="cb95-3" data-line-number="3">    <span class="fu">|</span> age <span class="fu">&lt;</span> <span class="dv">47</span> <span class="fu">=</span> <span class="st">&quot;Too low!&quot;</span></a>
-<a class="sourceLine" id="cb95-4" data-line-number="4">    <span class="fu">|</span> age <span class="fu">&gt;</span> <span class="dv">47</span> <span class="fu">=</span> <span class="st">&quot;Too high!&quot;</span></a>
-<a class="sourceLine" id="cb95-5" data-line-number="5">    <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="st">&quot;Correct!&quot;</span></a>
-<a class="sourceLine" id="cb95-6" data-line-number="6">guessAge <span class="st">&quot;Hansel&quot;</span> age</a>
-<a class="sourceLine" id="cb95-7" data-line-number="7">    <span class="fu">|</span> age <span class="fu">&lt;</span> <span class="dv">12</span> <span class="fu">=</span> <span class="st">&quot;Too low!&quot;</span></a>
-<a class="sourceLine" id="cb95-8" data-line-number="8">    <span class="fu">|</span> age <span class="fu">&gt;</span> <span class="dv">12</span> <span class="fu">=</span> <span class="st">&quot;Too high!&quot;</span></a>
-<a class="sourceLine" id="cb95-9" data-line-number="9">    <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="st">&quot;Correct!&quot;</span></a>
-<a class="sourceLine" id="cb95-10" data-line-number="10">guessAge name age <span class="fu">=</span> <span class="st">&quot;Wrong name!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb96"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb96-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">30</span></a>
-<a class="sourceLine" id="cb96-2" data-line-number="2"><span class="st">&quot;Too low!&quot;</span></a>
-<a class="sourceLine" id="cb96-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">60</span></a>
-<a class="sourceLine" id="cb96-4" data-line-number="4"><span class="st">&quot;Too high!&quot;</span></a>
-<a class="sourceLine" id="cb96-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">47</span></a>
-<a class="sourceLine" id="cb96-6" data-line-number="6"><span class="st">&quot;Correct!&quot;</span></a>
-<a class="sourceLine" id="cb96-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span></a>
-<a class="sourceLine" id="cb96-8" data-line-number="8"><span class="st">&quot;Wrong name!&quot;</span></a>
-<a class="sourceLine" id="cb96-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Hansel&quot;</span> <span class="dv">10</span></a>
-<a class="sourceLine" id="cb96-10" data-line-number="10"><span class="st">&quot;Too low!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb95"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb95-1" title="1"><span class="ot">guessAge ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb95-2" title="2">guessAge <span class="st">&quot;Griselda&quot;</span> age</a>
+<a class="sourceLine" id="cb95-3" title="3">    <span class="fu">|</span> age <span class="fu">&lt;</span> <span class="dv">47</span> <span class="fu">=</span> <span class="st">&quot;Too low!&quot;</span></a>
+<a class="sourceLine" id="cb95-4" title="4">    <span class="fu">|</span> age <span class="fu">&gt;</span> <span class="dv">47</span> <span class="fu">=</span> <span class="st">&quot;Too high!&quot;</span></a>
+<a class="sourceLine" id="cb95-5" title="5">    <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="st">&quot;Correct!&quot;</span></a>
+<a class="sourceLine" id="cb95-6" title="6">guessAge <span class="st">&quot;Hansel&quot;</span> age</a>
+<a class="sourceLine" id="cb95-7" title="7">    <span class="fu">|</span> age <span class="fu">&lt;</span> <span class="dv">12</span> <span class="fu">=</span> <span class="st">&quot;Too low!&quot;</span></a>
+<a class="sourceLine" id="cb95-8" title="8">    <span class="fu">|</span> age <span class="fu">&gt;</span> <span class="dv">12</span> <span class="fu">=</span> <span class="st">&quot;Too high!&quot;</span></a>
+<a class="sourceLine" id="cb95-9" title="9">    <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="st">&quot;Correct!&quot;</span></a>
+<a class="sourceLine" id="cb95-10" title="10">guessAge name age <span class="fu">=</span> <span class="st">&quot;Wrong name!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb96"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb96-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">30</span></a>
+<a class="sourceLine" id="cb96-2" title="2"><span class="st">&quot;Too low!&quot;</span></a>
+<a class="sourceLine" id="cb96-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">60</span></a>
+<a class="sourceLine" id="cb96-4" title="4"><span class="st">&quot;Too high!&quot;</span></a>
+<a class="sourceLine" id="cb96-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Griselda&quot;</span> <span class="dv">47</span></a>
+<a class="sourceLine" id="cb96-6" title="6"><span class="st">&quot;Correct!&quot;</span></a>
+<a class="sourceLine" id="cb96-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span></a>
+<a class="sourceLine" id="cb96-8" title="8"><span class="st">&quot;Wrong name!&quot;</span></a>
+<a class="sourceLine" id="cb96-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> guessAge <span class="st">&quot;Hansel&quot;</span> <span class="dv">10</span></a>
+<a class="sourceLine" id="cb96-10" title="10"><span class="st">&quot;Too low!&quot;</span></a></code></pre></div>
 <h2 id="lists"><span class="header-section-number">2.3</span> Lists</h2>
 <p>So far we’ve always worked with single values like number or booleans. Strings contain multiple characters, but still in some sense a string is just one piece of information. In order to be able to do actual programming, we need to handle variable numbers of items. For this we need <em>data structures</em>.</p>
 <p>The basic datastructure in Haskell is the list. Lists are used to store multiple values of the same type (in other words, Haskell lists are homogeneous). This is what a list literal looks like:</p>
-<div class="sourceCode" id="cb97"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb97-1" data-line-number="1">[<span class="dv">0</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb97"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb97-1" title="1">[<span class="dv">0</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>]</a></code></pre></div>
 <p>A list type is written as <code>[Element]</code>, where <code>Element</code> is the type of the lists elements. Here are some more list expressions and their types:</p>
-<div class="sourceCode" id="cb98"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb98-1" data-line-number="1">[<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> [<span class="dt">Bool</span>]</a>
-<a class="sourceLine" id="cb98-2" data-line-number="2">[<span class="st">&quot;Moi&quot;</span>,<span class="st">&quot;Hei&quot;</span>]<span class="ot"> ::</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb98-3" data-line-number="3">[]<span class="ot"> ::</span> [a]                   <span class="co">-- more about this later</span></a>
-<a class="sourceLine" id="cb98-4" data-line-number="4">[[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]]<span class="ot"> ::</span> [[<span class="dt">Int</span>]]    <span class="co">-- a list of lists</span></a>
-<a class="sourceLine" id="cb98-5" data-line-number="5">[<span class="dv">1</span><span class="fu">..</span><span class="dv">7</span>]<span class="ot"> ::</span> [<span class="dt">Int</span>]             <span class="co">-- range syntax, value [1,2,3,4,5,6,7]</span></a></code></pre></div>
+<div class="sourceCode" id="cb98"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb98-1" title="1">[<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> [<span class="dt">Bool</span>]</a>
+<a class="sourceLine" id="cb98-2" title="2">[<span class="st">&quot;Moi&quot;</span>,<span class="st">&quot;Hei&quot;</span>]<span class="ot"> ::</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb98-3" title="3">[]<span class="ot"> ::</span> [a]                   <span class="co">-- more about this later</span></a>
+<a class="sourceLine" id="cb98-4" title="4">[[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]]<span class="ot"> ::</span> [[<span class="dt">Int</span>]]    <span class="co">-- a list of lists</span></a>
+<a class="sourceLine" id="cb98-5" title="5">[<span class="dv">1</span><span class="fu">..</span><span class="dv">7</span>]<span class="ot"> ::</span> [<span class="dt">Int</span>]             <span class="co">-- range syntax, value [1,2,3,4,5,6,7]</span></a></code></pre></div>
 <p>Haskell lists are implemented as singly-linked lists. We’ll return to this later.</p>
 <h3 id="list-operations"><span class="header-section-number">2.3.1</span> List Operations</h3>
 <p>The Haskell standard library comes with lots of functions that operate on lists. Here are some of the most important ones, together with their types. We’ll get back to what <code>[a]</code> actually means in a second, but for now you can imagine it means “any list”.</p>
-<div class="sourceCode" id="cb99"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb99-1" data-line-number="1">head<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a            <span class="co">-- returns the first element</span></a>
-<a class="sourceLine" id="cb99-2" data-line-number="2">tail<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]          <span class="co">-- returns everything except the first element</span></a>
-<a class="sourceLine" id="cb99-3" data-line-number="3">init<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]          <span class="co">-- returns everything except the last element</span></a>
-<a class="sourceLine" id="cb99-4" data-line-number="4">take<span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- returns the n first elements</span></a>
-<a class="sourceLine" id="cb99-5" data-line-number="5">drop<span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- returns everything except the n first elements</span></a>
-<a class="sourceLine" id="cb99-6" data-line-number="6"><span class="ot">(++) ::</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- lists are catenated with the ++ operator</span></a>
-<a class="sourceLine" id="cb99-7" data-line-number="7"><span class="ot">(!!) ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> a     <span class="co">-- lists are indexed with the !! operator</span></a>
-<a class="sourceLine" id="cb99-8" data-line-number="8">reverse<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]       <span class="co">-- reverse a list</span></a>
-<a class="sourceLine" id="cb99-9" data-line-number="9">null<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span>         <span class="co">-- is this list empty?</span></a>
-<a class="sourceLine" id="cb99-10" data-line-number="10">length<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Int</span>        <span class="co">-- the length of a list</span></a></code></pre></div>
+<div class="sourceCode" id="cb99"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb99-1" title="1"><span class="fu">head</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a            <span class="co">-- returns the first element</span></a>
+<a class="sourceLine" id="cb99-2" title="2"><span class="fu">tail</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]          <span class="co">-- returns everything except the first element</span></a>
+<a class="sourceLine" id="cb99-3" title="3"><span class="fu">init</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]          <span class="co">-- returns everything except the last element</span></a>
+<a class="sourceLine" id="cb99-4" title="4"><span class="fu">take</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- returns the n first elements</span></a>
+<a class="sourceLine" id="cb99-5" title="5"><span class="fu">drop</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- returns everything except the n first elements</span></a>
+<a class="sourceLine" id="cb99-6" title="6"><span class="ot">(++) ::</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- lists are catenated with the ++ operator</span></a>
+<a class="sourceLine" id="cb99-7" title="7"><span class="ot">(!!) ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> a     <span class="co">-- lists are indexed with the !! operator</span></a>
+<a class="sourceLine" id="cb99-8" title="8"><span class="fu">reverse</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]       <span class="co">-- reverse a list</span></a>
+<a class="sourceLine" id="cb99-9" title="9"><span class="fu">null</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span>         <span class="co">-- is this list empty?</span></a>
+<a class="sourceLine" id="cb99-10" title="10"><span class="fu">length</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Int</span>        <span class="co">-- the length of a list</span></a></code></pre></div>
 <p>Sidenote: the last two operations (<code>null</code> and <code>length</code>) actually have more generic types, but here I’m pretending that you can only use them on lists.</p>
 <p>Lists can be compared with the familiar <code>==</code> operator.</p>
 <p>Do you remember this from our first GHCi session?</p>
-<div class="sourceCode" id="cb100"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb100-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="st">&quot;asdf&quot;</span></a>
-<a class="sourceLine" id="cb100-2" data-line-number="2"><span class="st">&quot;asdf&quot;</span><span class="ot"> ::</span> [<span class="dt">Char</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb100"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb100-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="st">&quot;asdf&quot;</span></a>
+<a class="sourceLine" id="cb100-2" title="2"><span class="st">&quot;asdf&quot;</span><span class="ot"> ::</span> [<span class="dt">Char</span>]</a></code></pre></div>
 <p>This means that <code>String</code> is just an alias for <code>[Char]</code>, which means string is a list of characters. This means you can use all list operations on strings!</p>
 <p>Some list operations come from the module <code>Data.List</code>. You can import a module in code or in GHCi with the <code>import Data.List</code> syntax. One example is the <code>sort</code> function which sorts a list:</p>
-<div class="sourceCode" id="cb101"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb101-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
-<a class="sourceLine" id="cb101-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb101-3" data-line-number="3">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">5</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb101"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb101-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
+<a class="sourceLine" id="cb101-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb101-3" title="3">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">5</span>]</a></code></pre></div>
 <p>Note how the set of imported modules shows up in the GHCi prompt.</p>
 <h3 id="examples-2"><span class="header-section-number">2.3.2</span> Examples</h3>
 <p>Here are some examples of working with lists. In this case, instead of showing you output from GHCi, I merely use <code>==&gt;</code> to show what an expression evaluates to.</p>
 <p>Indexing a list:</p>
-<div class="sourceCode" id="cb102"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb102-1" data-line-number="1">[<span class="dv">7</span>,<span class="dv">10</span>,<span class="dv">4</span>,<span class="dv">5</span>] <span class="fu">!!</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb102-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
+<div class="sourceCode" id="cb102"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb102-1" title="1">[<span class="dv">7</span>,<span class="dv">10</span>,<span class="dv">4</span>,<span class="dv">5</span>] <span class="fu">!!</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb102-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
 <p>Defining a function that discards the 3rd and 4th elements of a list using <code>take</code> and <code>drop</code>:</p>
-<div class="sourceCode" id="cb103"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb103-1" data-line-number="1">f xs <span class="fu">=</span> take <span class="dv">2</span> xs <span class="fu">++</span> drop <span class="dv">4</span> xs</a></code></pre></div>
-<div class="sourceCode" id="cb104"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb104-1" data-line-number="1">f [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">5</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb104-2" data-line-number="2">f [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]        <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb103"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb103-1" title="1">f xs <span class="fu">=</span> <span class="fu">take</span> <span class="dv">2</span> xs <span class="fu">++</span> <span class="fu">drop</span> <span class="dv">4</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb104"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb104-1" title="1">f [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">5</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb104-2" title="2">f [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]        <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
 <p>Rotating a list by taking the first element and moving it to the end:</p>
-<div class="sourceCode" id="cb105"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb105-1" data-line-number="1">g xs <span class="fu">=</span> tail xs <span class="fu">++</span> [head xs]</a></code></pre></div>
-<div class="sourceCode" id="cb106"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb106-1" data-line-number="1">g [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]      <span class="fu">==&gt;</span>  [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb106-2" data-line-number="2">g (g [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  [<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb105"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb105-1" title="1">g xs <span class="fu">=</span> <span class="fu">tail</span> xs <span class="fu">++</span> [<span class="fu">head</span> xs]</a></code></pre></div>
+<div class="sourceCode" id="cb106"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb106-1" title="1">g [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]      <span class="fu">==&gt;</span>  [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb106-2" title="2">g (g [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  [<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
 <p>Here’s an example of the range syntax:</p>
-<div class="sourceCode" id="cb107"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb107-1" data-line-number="1">reverse [<span class="dv">1</span><span class="fu">..</span><span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb107"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb107-1" title="1"><span class="fu">reverse</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
 <h2 id="a-word-about-immutability-1"><span class="header-section-number">2.4</span> A Word About Immutability</h2>
 <p>Because Haskell is pure, it also means that functions can’t <em>mutate</em> (change) their inputs. Mutation is a side effect, and Haskell functions are only allowed output via their return value. This means that Haskell list functions always return a new list. In practice:</p>
-<div class="sourceCode" id="cb108"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb108-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> list <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb108-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> reverse list</a>
-<a class="sourceLine" id="cb108-3" data-line-number="3">[<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb108-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> list</a>
-<a class="sourceLine" id="cb108-5" data-line-number="5">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb108-6" data-line-number="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> drop <span class="dv">2</span> list</a>
-<a class="sourceLine" id="cb108-7" data-line-number="7">[<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb108-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> list</a>
-<a class="sourceLine" id="cb108-9" data-line-number="9">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb108"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb108-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> list <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb108-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">reverse</span> list</a>
+<a class="sourceLine" id="cb108-3" title="3">[<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb108-4" title="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> list</a>
+<a class="sourceLine" id="cb108-5" title="5">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb108-6" title="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">drop</span> <span class="dv">2</span> list</a>
+<a class="sourceLine" id="cb108-7" title="7">[<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb108-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> list</a>
+<a class="sourceLine" id="cb108-9" title="9">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <p>This might seem very inefficient but it turns out it can be both performant and quite useful. We’ll get back to how Haskell datastructures work in a later lecture.</p>
 <h2 id="a-word-about-type-inference-and-polymorphism"><span class="header-section-number">2.5</span> A Word About Type Inference and Polymorphism</h2>
 <p>So what does a type like <code>head :: [a] -&gt; a</code> mean? It means given a list that contains elements of any type <code>a</code>, the return value will be of the same type <code>a</code>.</p>
 <p>In this type, <code>a</code> is a <em>type variable</em>. Type variables are types that start with a small letter, e.g. <code>a</code>, <code>b</code>, <code>thisIsATypeVariable</code>. A type variable means a type that is not yet known, or in other words a type that could be anything. Type variables can turn into <em>concrete types</em> (e.g. <code>Bool</code>) by the process of <em>type inference</em> (also called <em>unification</em>).</p>
 <p>Let’s have a look at some examples. If we apply <code>head</code> to a list of booleans, type inference will compare the type of head’s argument, <code>[a]</code>, with the type of the actual argument, <code>[Bool]</code> and deduce that <code>a</code> must be <code>Bool</code>. This means that the return type of <code>head</code> will in this case also be <code>Bool</code>.</p>
-<div class="sourceCode" id="cb109"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb109-1" data-line-number="1">head<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb109-2" data-line-number="2">head [<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb109"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb109-1" title="1"><span class="fu">head</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb109-2" title="2"><span class="fu">head</span> [<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>The function <code>tail</code> takes a list, and returns a list of the same type. If we apply <code>tail</code> to a list of booleans, the return value will also be a list of booleans.</p>
-<div class="sourceCode" id="cb110"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb110-1" data-line-number="1">tail<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb110-2" data-line-number="2">tail [<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> [<span class="dt">Bool</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb110"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb110-1" title="1"><span class="fu">tail</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb110-2" title="2"><span class="fu">tail</span> [<span class="dt">True</span>,<span class="dt">False</span>]<span class="ot"> ::</span> [<span class="dt">Bool</span>]</a></code></pre></div>
 <p>If types don’t match, we get a type error. Consider the operator <code>++</code> which takes two lists of the same type, as we can see from its type <code>[a] -&gt; [a] -&gt; [a]</code>. If we try to apply <code>++</code> to a list of booleans and a list of characters we get an error. This is what happens in GHCi:</p>
 <pre><code>Prelude&gt; [True,False] ++ &quot;Moi&quot;
 
@@ -1319,14 +1317,14 @@ Ok, two modules loaded.
     In the second argument of `(++)&#39;, namely `&quot;Moi&quot;&#39;
     In the expression: [True, False] ++ &quot;Moi&quot;</code></pre>
 <p>Type inference is really powerful. It uses the simple process of unification to get us types for practically any Haskell expression. Consider these two functions:</p>
-<div class="sourceCode" id="cb112"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb112-1" data-line-number="1">f xs ys <span class="fu">=</span> [head xs, head ys]</a>
-<a class="sourceLine" id="cb112-2" data-line-number="2">g zs <span class="fu">=</span> f <span class="st">&quot;Moi&quot;</span> zs</a></code></pre></div>
+<div class="sourceCode" id="cb112"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb112-1" title="1">f xs ys <span class="fu">=</span> [<span class="fu">head</span> xs, <span class="fu">head</span> ys]</a>
+<a class="sourceLine" id="cb112-2" title="2">g zs <span class="fu">=</span> f <span class="st">&quot;Moi&quot;</span> zs</a></code></pre></div>
 <p>We can ask GHCi for their types, and we will see that type inference has figured out that the two arguments to <code>f</code> must have the same type, since their heads get put into the same list.</p>
-<div class="sourceCode" id="cb113"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb113-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t f</a>
-<a class="sourceLine" id="cb113-2" data-line-number="2"><span class="ot">f ::</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb113"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb113-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t f</a>
+<a class="sourceLine" id="cb113-2" title="2"><span class="ot">f ::</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>The function <code>g</code>, which fixed one of the arguments of <code>f</code> to a string (i.e. <code>[Char]</code>) gets a narrower type. Type inference has decided that the argument <code>zs</code> to <code>g</code> must also have type <code>[Char]</code>, since otherwise the type of <code>f</code> would not match the call to <code>f</code>.</p>
-<div class="sourceCode" id="cb114"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb114-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t g</a>
-<a class="sourceLine" id="cb114-2" data-line-number="2"><span class="ot">g ::</span> [<span class="dt">Char</span>] <span class="ot">-&gt;</span> [<span class="dt">Char</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb114"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb114-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t g</a>
+<a class="sourceLine" id="cb114-2" title="2"><span class="ot">g ::</span> [<span class="dt">Char</span>] <span class="ot">-&gt;</span> [<span class="dt">Char</span>]</a></code></pre></div>
 <h3 id="sidenote-some-terminology"><span class="header-section-number">2.5.1</span> Sidenote: Some Terminology</h3>
 <p>In a type like <code>[Char]</code> we call <code>Char</code> a <em>type parameter</em>. A type like the list type that needs a type parameter is called a <em>parameterized type</em>.</p>
 <p>The fact that a function like <code>head</code> can be used with many different types of arguments is called <em>polymorphism</em>. The <code>head</code> function is said to be <em>polymorphic</em>. There are many forms of polymorphism, and this Haskell form that uses type variables is called <em>parametric polymorphism</em>.</p>
@@ -1366,41 +1364,41 @@ Ok, two modules loaded.
 </table>
 <p>You can think of <code>Maybe a</code> as being a bit like <code>[a]</code> except there can only be 0 or 1 elements, not more. Alternatively, you can think of <code>Maybe a</code> introducing a null value to the type <code>a</code>. If you’re familiar with Java, <code>Maybe Integer</code> is the Haskell equivalent of Java’s <code>Optional&lt;Integer&gt;</code>.</p>
 <p>You can create <code>Maybe</code> values by either specifying <code>Nothing</code> or <code>Just someOtherValue</code>:</p>
-<div class="sourceCode" id="cb115"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb115-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb115-2" data-line-number="2"><span class="dt">Nothing</span><span class="ot"> ::</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb115-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
-<a class="sourceLine" id="cb115-4" data-line-number="4"><span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
-<a class="sourceLine" id="cb115-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
-<a class="sourceLine" id="cb115-6" data-line-number="6"><span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> [<span class="dt">Char</span>]   <span class="co">-- the same as Maybe String</span></a>
-<a class="sourceLine" id="cb115-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Just</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb115-8" data-line-number="8"><span class="dt">Just</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb115-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Just</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb115-10" data-line-number="10"><span class="dt">Just</span> <span class="dt">True</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Bool</span></a></code></pre></div>
-<div class="sourceCode" id="cb116"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb116-1" data-line-number="1"><span class="co">-- given a password, return (Just username) if login succeeds, Nothing otherwise</span></a>
-<a class="sourceLine" id="cb116-2" data-line-number="2"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb116-3" data-line-number="3">login <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;unicorn73&quot;</span></a>
-<a class="sourceLine" id="cb116-4" data-line-number="4">login <span class="st">&quot;swordfish&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;megahacker&quot;</span></a>
-<a class="sourceLine" id="cb116-5" data-line-number="5">login _           <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb115"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb115-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb115-2" title="2"><span class="dt">Nothing</span><span class="ot"> ::</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb115-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
+<a class="sourceLine" id="cb115-4" title="4"><span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
+<a class="sourceLine" id="cb115-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span></a>
+<a class="sourceLine" id="cb115-6" title="6"><span class="dt">Just</span> <span class="st">&quot;a camel&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> [<span class="dt">Char</span>]   <span class="co">-- the same as Maybe String</span></a>
+<a class="sourceLine" id="cb115-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Just</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb115-8" title="8"><span class="dt">Just</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb115-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Just</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb115-10" title="10"><span class="dt">Just</span> <span class="dt">True</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb116"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb116-1" title="1"><span class="co">-- given a password, return (Just username) if login succeeds, Nothing otherwise</span></a>
+<a class="sourceLine" id="cb116-2" title="2"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb116-3" title="3">login <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;unicorn73&quot;</span></a>
+<a class="sourceLine" id="cb116-4" title="4">login <span class="st">&quot;swordfish&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;megahacker&quot;</span></a>
+<a class="sourceLine" id="cb116-5" title="5">login _           <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>You use a <code>Maybe</code> value by pattern matching on it. Usually you define patterns for the <code>Nothing</code> and <code>Just something</code> cases. Some examples:</p>
-<div class="sourceCode" id="cb117"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb117-1" data-line-number="1"><span class="co">-- Multiply an Int with a Maybe Int. Nothing is treated as no multiplication at all.</span></a>
-<a class="sourceLine" id="cb117-2" data-line-number="2"><span class="ot">perhapsMultiply ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb117-3" data-line-number="3">perhapsMultiply i <span class="dt">Nothing</span> <span class="fu">=</span> i</a>
-<a class="sourceLine" id="cb117-4" data-line-number="4">perhapsMultiply i (<span class="dt">Just</span> j) <span class="fu">=</span> i<span class="fu">*</span>j   <span class="co">-- Note how j denotes the value inside the Just</span></a></code></pre></div>
-<div class="sourceCode" id="cb118"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb118-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> perhapsMultiply <span class="dv">3</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb118-2" data-line-number="2"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb118-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> perhapsMultiply <span class="dv">3</span> (<span class="dt">Just</span> <span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb118-4" data-line-number="4"><span class="dv">6</span></a></code></pre></div>
-<div class="sourceCode" id="cb119"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb119-1" data-line-number="1"><span class="ot">intOrZero ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb119-2" data-line-number="2">intOrZero <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb119-3" data-line-number="3">intOrZero (<span class="dt">Just</span> i) <span class="fu">=</span> i</a>
-<a class="sourceLine" id="cb119-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb119-5" data-line-number="5"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb119-6" data-line-number="6">safeHead xs <span class="fu">=</span> <span class="kw">if</span> null xs <span class="kw">then</span> <span class="dt">Nothing</span> <span class="kw">else</span> <span class="dt">Just</span> (head xs)</a>
-<a class="sourceLine" id="cb119-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb119-8" data-line-number="8"><span class="ot">headOrZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb119-9" data-line-number="9">headOrZero xs <span class="fu">=</span> intOrZero (safeHead xs)</a></code></pre></div>
-<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb120-1" data-line-number="1">headOrZero []  <span class="fu">==&gt;</span> intOrZero (safeHead [])  <span class="fu">==&gt;</span> intOrZero <span class="dt">Nothing</span>  <span class="fu">==&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb120-2" data-line-number="2">headOrZero [<span class="dv">1</span>] <span class="fu">==&gt;</span> intOrZero (safeHead [<span class="dv">1</span>]) <span class="fu">==&gt;</span> intOrZero (<span class="dt">Just</span> <span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb117"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb117-1" title="1"><span class="co">-- Multiply an Int with a Maybe Int. Nothing is treated as no multiplication at all.</span></a>
+<a class="sourceLine" id="cb117-2" title="2"><span class="ot">perhapsMultiply ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb117-3" title="3">perhapsMultiply i <span class="dt">Nothing</span> <span class="fu">=</span> i</a>
+<a class="sourceLine" id="cb117-4" title="4">perhapsMultiply i (<span class="dt">Just</span> j) <span class="fu">=</span> i<span class="fu">*</span>j   <span class="co">-- Note how j denotes the value inside the Just</span></a></code></pre></div>
+<div class="sourceCode" id="cb118"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb118-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> perhapsMultiply <span class="dv">3</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb118-2" title="2"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb118-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> perhapsMultiply <span class="dv">3</span> (<span class="dt">Just</span> <span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb118-4" title="4"><span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb119"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb119-1" title="1"><span class="ot">intOrZero ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb119-2" title="2">intOrZero <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb119-3" title="3">intOrZero (<span class="dt">Just</span> i) <span class="fu">=</span> i</a>
+<a class="sourceLine" id="cb119-4" title="4"></a>
+<a class="sourceLine" id="cb119-5" title="5"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb119-6" title="6">safeHead xs <span class="fu">=</span> <span class="kw">if</span> <span class="fu">null</span> xs <span class="kw">then</span> <span class="dt">Nothing</span> <span class="kw">else</span> <span class="dt">Just</span> (<span class="fu">head</span> xs)</a>
+<a class="sourceLine" id="cb119-7" title="7"></a>
+<a class="sourceLine" id="cb119-8" title="8"><span class="ot">headOrZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb119-9" title="9">headOrZero xs <span class="fu">=</span> intOrZero (safeHead xs)</a></code></pre></div>
+<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb120-1" title="1">headOrZero []  <span class="fu">==&gt;</span> intOrZero (safeHead [])  <span class="fu">==&gt;</span> intOrZero <span class="dt">Nothing</span>  <span class="fu">==&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb120-2" title="2">headOrZero [<span class="dv">1</span>] <span class="fu">==&gt;</span> intOrZero (safeHead [<span class="dv">1</span>]) <span class="fu">==&gt;</span> intOrZero (<span class="dt">Just</span> <span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="dv">1</span></a></code></pre></div>
 <h2 id="sidenote-constructors"><span class="header-section-number">2.7</span> Sidenote: Constructors</h2>
 <p>As you can see above, we can pattern match on the constructors of <code>Maybe</code>: <code>Just</code> and <code>Nothing</code>. We’ll get back to what constructors mean later. For now it’s enough to note that constructors are special values that start with a capital letter that you can pattern match on.</p>
 <p>Other constructors that we’ve already seen include the constructors of <code>Bool</code> – <code>True</code> and <code>False</code>. We’ll introduce the constructors of the list type on the next lecture.</p>
@@ -1432,69 +1430,69 @@ Just :: a -&gt; Maybe a</code></pre>
 </tbody>
 </table>
 <p>Here’s a simple example: a <code>readInt</code> function that only knows a couple of numbers and returns a descriptive error for the rest. Note the Haskell convention of using <code>Left</code> for errors and <code>Right</code> for success.</p>
-<div class="sourceCode" id="cb122"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb122-1" data-line-number="1">readInt<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Either</span> <span class="dt">String</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb122-2" data-line-number="2">readInt <span class="st">&quot;0&quot;</span> <span class="fu">=</span> <span class="dt">Right</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb122-3" data-line-number="3">readInt <span class="st">&quot;1&quot;</span> <span class="fu">=</span> <span class="dt">Right</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb122-4" data-line-number="4">readInt s <span class="fu">=</span> <span class="dt">Left</span> (<span class="st">&quot;Unsupported string: &quot;</span> <span class="fu">++</span> s)</a></code></pre></div>
+<div class="sourceCode" id="cb122"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb122-1" title="1"><span class="fu">readInt</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Either</span> <span class="dt">String</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb122-2" title="2"><span class="fu">readInt</span> <span class="st">&quot;0&quot;</span> <span class="fu">=</span> <span class="dt">Right</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb122-3" title="3"><span class="fu">readInt</span> <span class="st">&quot;1&quot;</span> <span class="fu">=</span> <span class="dt">Right</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb122-4" title="4"><span class="fu">readInt</span> s <span class="fu">=</span> <span class="dt">Left</span> (<span class="st">&quot;Unsupported string: &quot;</span> <span class="fu">++</span> s)</a></code></pre></div>
 <p>Sidenote: the constructors of <code>Either</code> are called <code>Left</code> and <code>Right</code> because they refer to the left and right type arguments of <code>Either</code>. Note how in <code>Either a b</code>, <code>a</code> is the left argument and <code>b</code> is the right argument. Thus <code>Left</code> contains a value of type <code>a</code> and likewise <code>Right</code> of type <code>b</code>. The convention of using <code>Right</code> for success is probably simply because right also means correct. No offense is intended to left-handed people.</p>
 <p>Here’s another example: pattern matching an <code>Either</code>. Just like with <code>Maybe</code>, there are two patterns for an <code>Either</code>, one for each constructor.</p>
-<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb123-1" data-line-number="1"><span class="ot">iWantAString ::</span> <span class="dt">Either</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb123-2" data-line-number="2">iWantAString (<span class="dt">Right</span> str)   <span class="fu">=</span> str</a>
-<a class="sourceLine" id="cb123-3" data-line-number="3">iWantAString (<span class="dt">Left</span> number) <span class="fu">=</span> show number</a></code></pre></div>
+<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb123-1" title="1"><span class="ot">iWantAString ::</span> <span class="dt">Either</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb123-2" title="2">iWantAString (<span class="dt">Right</span> str)   <span class="fu">=</span> str</a>
+<a class="sourceLine" id="cb123-3" title="3">iWantAString (<span class="dt">Left</span> number) <span class="fu">=</span> <span class="fu">show</span> number</a></code></pre></div>
 <p>As you recall, Haskell lists can only contain elements of the same type. You can’t have a value like <code>[1,&quot;foo&quot;,2]</code>. However, you can use a type like <code>Either</code> to represent lists that can contain two different types of values. For example we could track the number of people on a lecture, with a possibility of adding an explanation if a value is missing:</p>
 <pre><code>lectureParticipants :: [Either String Int]
 lectureParticipants = [Right 10, Right 13, Left &quot;easter vacation&quot;, Right 17, Left &quot;lecturer was sick&quot;, Right 3]</code></pre>
 <h2 id="the-case-of-expression"><span class="header-section-number">2.9</span> The case-of Expression</h2>
 <p>We’ve seen pattern matching in function arguments, but there’s also a way to pattern match in an expression. It looks like this:</p>
-<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb125-1" data-line-number="1"><span class="kw">case</span> <span class="fu">&lt;</span>value<span class="fu">&gt;</span> <span class="kw">of</span> <span class="fu">&lt;</span>pattern<span class="fu">&gt;</span> <span class="ot">-&gt;</span> <span class="fu">&lt;</span>expression<span class="fu">&gt;</span></a>
-<a class="sourceLine" id="cb125-2" data-line-number="2">                <span class="fu">&lt;</span>pattern<span class="fu">&gt;</span> <span class="ot">-&gt;</span> <span class="fu">&lt;</span>expression<span class="fu">&gt;</span></a></code></pre></div>
+<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb125-1" title="1"><span class="kw">case</span> <span class="fu">&lt;</span>value<span class="fu">&gt;</span> <span class="kw">of</span> <span class="fu">&lt;</span><span class="kw">pattern</span><span class="fu">&gt;</span> <span class="ot">-&gt;</span> <span class="fu">&lt;</span>expression<span class="fu">&gt;</span></a>
+<a class="sourceLine" id="cb125-2" title="2">                <span class="fu">&lt;</span><span class="kw">pattern</span><span class="fu">&gt;</span> <span class="ot">-&gt;</span> <span class="fu">&lt;</span>expression<span class="fu">&gt;</span></a></code></pre></div>
 <p>As an example let’s rewrite the <code>describe</code> example from the first lecture using <code>case</code>:</p>
-<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb126-1" data-line-number="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb126-2" data-line-number="2">describe <span class="dv">0</span> <span class="fu">=</span> <span class="st">&quot;zero&quot;</span></a>
-<a class="sourceLine" id="cb126-3" data-line-number="3">describe <span class="dv">1</span> <span class="fu">=</span> <span class="st">&quot;one&quot;</span></a>
-<a class="sourceLine" id="cb126-4" data-line-number="4">describe <span class="dv">2</span> <span class="fu">=</span> <span class="st">&quot;an even prime&quot;</span></a>
-<a class="sourceLine" id="cb126-5" data-line-number="5">describe n <span class="fu">=</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> show n</a></code></pre></div>
-<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb127-1" data-line-number="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb127-2" data-line-number="2">describe n <span class="fu">=</span> <span class="kw">case</span> n <span class="kw">of</span> <span class="dv">0</span> <span class="ot">-&gt;</span> <span class="st">&quot;zero&quot;</span></a>
-<a class="sourceLine" id="cb127-3" data-line-number="3">                       <span class="dv">1</span> <span class="ot">-&gt;</span> <span class="st">&quot;one&quot;</span></a>
-<a class="sourceLine" id="cb127-4" data-line-number="4">                       <span class="dv">2</span> <span class="ot">-&gt;</span> <span class="st">&quot;an even prime&quot;</span></a>
-<a class="sourceLine" id="cb127-5" data-line-number="5">                       n <span class="ot">-&gt;</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> show n</a></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb126-1" title="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb126-2" title="2">describe <span class="dv">0</span> <span class="fu">=</span> <span class="st">&quot;zero&quot;</span></a>
+<a class="sourceLine" id="cb126-3" title="3">describe <span class="dv">1</span> <span class="fu">=</span> <span class="st">&quot;one&quot;</span></a>
+<a class="sourceLine" id="cb126-4" title="4">describe <span class="dv">2</span> <span class="fu">=</span> <span class="st">&quot;an even prime&quot;</span></a>
+<a class="sourceLine" id="cb126-5" title="5">describe n <span class="fu">=</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> <span class="fu">show</span> n</a></code></pre></div>
+<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb127-1" title="1"><span class="ot">describe ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb127-2" title="2">describe n <span class="fu">=</span> <span class="kw">case</span> n <span class="kw">of</span> <span class="dv">0</span> <span class="ot">-&gt;</span> <span class="st">&quot;zero&quot;</span></a>
+<a class="sourceLine" id="cb127-3" title="3">                       <span class="dv">1</span> <span class="ot">-&gt;</span> <span class="st">&quot;one&quot;</span></a>
+<a class="sourceLine" id="cb127-4" title="4">                       <span class="dv">2</span> <span class="ot">-&gt;</span> <span class="st">&quot;an even prime&quot;</span></a>
+<a class="sourceLine" id="cb127-5" title="5">                       n <span class="ot">-&gt;</span> <span class="st">&quot;the number &quot;</span> <span class="fu">++</span> <span class="fu">show</span> n</a></code></pre></div>
 <p>A more interesting example is when the value we’re pattern matching on is not a function argument. For example:</p>
-<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb128-1" data-line-number="1"><span class="co">-- parse country code into country name, returns Nothing if code not recognized</span></a>
-<a class="sourceLine" id="cb128-2" data-line-number="2"><span class="ot">parseCountry ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb128-3" data-line-number="3">parseCountry <span class="st">&quot;FI&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;Finland&quot;</span></a>
-<a class="sourceLine" id="cb128-4" data-line-number="4">parseCountry <span class="st">&quot;SE&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;Sweden&quot;</span></a>
-<a class="sourceLine" id="cb128-5" data-line-number="5">parseCountry _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb128-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb128-7" data-line-number="7"><span class="ot">flyTo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb128-8" data-line-number="8">flyTo countryCode <span class="fu">=</span> <span class="kw">case</span> parseCountry countryCode <span class="kw">of</span> <span class="dt">Just</span> country <span class="ot">-&gt;</span> <span class="st">&quot;You&#39;re flying to &quot;</span> <span class="fu">++</span> country</a>
-<a class="sourceLine" id="cb128-9" data-line-number="9">                                                     <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb129-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> flyTo <span class="st">&quot;FI&quot;</span></a>
-<a class="sourceLine" id="cb129-2" data-line-number="2"><span class="st">&quot;You&#39;re flying to Finland&quot;</span></a>
-<a class="sourceLine" id="cb129-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> flyTo <span class="st">&quot;DE&quot;</span></a>
-<a class="sourceLine" id="cb129-4" data-line-number="4"><span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb128-1" title="1"><span class="co">-- parse country code into country name, returns Nothing if code not recognized</span></a>
+<a class="sourceLine" id="cb128-2" title="2"><span class="ot">parseCountry ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb128-3" title="3">parseCountry <span class="st">&quot;FI&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;Finland&quot;</span></a>
+<a class="sourceLine" id="cb128-4" title="4">parseCountry <span class="st">&quot;SE&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;Sweden&quot;</span></a>
+<a class="sourceLine" id="cb128-5" title="5">parseCountry _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb128-6" title="6"></a>
+<a class="sourceLine" id="cb128-7" title="7"><span class="ot">flyTo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb128-8" title="8">flyTo countryCode <span class="fu">=</span> <span class="kw">case</span> parseCountry countryCode <span class="kw">of</span> <span class="dt">Just</span> country <span class="ot">-&gt;</span> <span class="st">&quot;You&#39;re flying to &quot;</span> <span class="fu">++</span> country</a>
+<a class="sourceLine" id="cb128-9" title="9">                                                     <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb129-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> flyTo <span class="st">&quot;FI&quot;</span></a>
+<a class="sourceLine" id="cb129-2" title="2"><span class="st">&quot;You&#39;re flying to Finland&quot;</span></a>
+<a class="sourceLine" id="cb129-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> flyTo <span class="st">&quot;DE&quot;</span></a>
+<a class="sourceLine" id="cb129-4" title="4"><span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
 <p>We could write the <code>flyTo</code> function using a helper function for pattern matching instead of using the case-of expression:</p>
-<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb130-1" data-line-number="1"><span class="ot">flyTo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb130-2" data-line-number="2">flyTo countryCode <span class="fu">=</span> handleResult (parseCountry countryCode)</a>
-<a class="sourceLine" id="cb130-3" data-line-number="3">  <span class="kw">where</span> handleResult (<span class="dt">Just</span> country) <span class="fu">=</span> <span class="st">&quot;You&#39;re flying to &quot;</span> <span class="fu">++</span> country</a>
-<a class="sourceLine" id="cb130-4" data-line-number="4">        handleResult <span class="dt">Nothing</span>        <span class="fu">=</span> <span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb130-1" title="1"><span class="ot">flyTo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb130-2" title="2">flyTo countryCode <span class="fu">=</span> handleResult (parseCountry countryCode)</a>
+<a class="sourceLine" id="cb130-3" title="3">  <span class="kw">where</span> handleResult (<span class="dt">Just</span> country) <span class="fu">=</span> <span class="st">&quot;You&#39;re flying to &quot;</span> <span class="fu">++</span> country</a>
+<a class="sourceLine" id="cb130-4" title="4">        handleResult <span class="dt">Nothing</span>        <span class="fu">=</span> <span class="st">&quot;You&#39;re not flying anywhere&quot;</span></a></code></pre></div>
 <p>In fact, a case-of expression can always be replaced with a helper function. Here’s one more example, written in both ways:</p>
-<div class="sourceCode" id="cb131"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb131-1" data-line-number="1"><span class="co">-- given a sentence, decide whether it is a statement, question or exclamation</span></a>
-<a class="sourceLine" id="cb131-2" data-line-number="2"><span class="ot">sentenceType ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb131-3" data-line-number="3">sentenceType sentence <span class="fu">=</span> <span class="kw">case</span> last sentence <span class="kw">of</span> <span class="ch">&#39;.&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;statement&quot;</span></a>
-<a class="sourceLine" id="cb131-4" data-line-number="4">                                              <span class="ch">&#39;?&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;question&quot;</span></a>
-<a class="sourceLine" id="cb131-5" data-line-number="5">                                              <span class="ch">&#39;!&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;exclamation&quot;</span></a>
-<a class="sourceLine" id="cb131-6" data-line-number="6">                                              _   <span class="ot">-&gt;</span> <span class="st">&quot;not a sentence&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb132"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb132-1" data-line-number="1"><span class="co">-- same function, helper function instead of case-of</span></a>
-<a class="sourceLine" id="cb132-2" data-line-number="2">sentenceType sentence <span class="fu">=</span> classify (last sentence)</a>
-<a class="sourceLine" id="cb132-3" data-line-number="3">  <span class="kw">where</span> classify <span class="ch">&#39;.&#39;</span> <span class="fu">=</span> <span class="st">&quot;statement&quot;</span></a>
-<a class="sourceLine" id="cb132-4" data-line-number="4">        classify <span class="ch">&#39;?&#39;</span> <span class="fu">=</span> <span class="st">&quot;question&quot;</span></a>
-<a class="sourceLine" id="cb132-5" data-line-number="5">        classify <span class="ch">&#39;!&#39;</span> <span class="fu">=</span> <span class="st">&quot;exclamation&quot;</span></a>
-<a class="sourceLine" id="cb132-6" data-line-number="6">        classify _   <span class="fu">=</span> <span class="st">&quot;not a sentence&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb133"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb133-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> sentenceType <span class="st">&quot;This is Haskell.&quot;</span></a>
-<a class="sourceLine" id="cb133-2" data-line-number="2"><span class="st">&quot;statement&quot;</span></a>
-<a class="sourceLine" id="cb133-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> sentenceType <span class="st">&quot;This is Haskell!&quot;</span></a>
-<a class="sourceLine" id="cb133-4" data-line-number="4"><span class="st">&quot;exclamation&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb131"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb131-1" title="1"><span class="co">-- given a sentence, decide whether it is a statement, question or exclamation</span></a>
+<a class="sourceLine" id="cb131-2" title="2"><span class="ot">sentenceType ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb131-3" title="3">sentenceType sentence <span class="fu">=</span> <span class="kw">case</span> <span class="fu">last</span> sentence <span class="kw">of</span> <span class="ch">&#39;.&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;statement&quot;</span></a>
+<a class="sourceLine" id="cb131-4" title="4">                                              <span class="ch">&#39;?&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;question&quot;</span></a>
+<a class="sourceLine" id="cb131-5" title="5">                                              <span class="ch">&#39;!&#39;</span> <span class="ot">-&gt;</span> <span class="st">&quot;exclamation&quot;</span></a>
+<a class="sourceLine" id="cb131-6" title="6">                                              _   <span class="ot">-&gt;</span> <span class="st">&quot;not a sentence&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb132"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb132-1" title="1"><span class="co">-- same function, helper function instead of case-of</span></a>
+<a class="sourceLine" id="cb132-2" title="2">sentenceType sentence <span class="fu">=</span> classify (<span class="fu">last</span> sentence)</a>
+<a class="sourceLine" id="cb132-3" title="3">  <span class="kw">where</span> classify <span class="ch">&#39;.&#39;</span> <span class="fu">=</span> <span class="st">&quot;statement&quot;</span></a>
+<a class="sourceLine" id="cb132-4" title="4">        classify <span class="ch">&#39;?&#39;</span> <span class="fu">=</span> <span class="st">&quot;question&quot;</span></a>
+<a class="sourceLine" id="cb132-5" title="5">        classify <span class="ch">&#39;!&#39;</span> <span class="fu">=</span> <span class="st">&quot;exclamation&quot;</span></a>
+<a class="sourceLine" id="cb132-6" title="6">        classify _   <span class="fu">=</span> <span class="st">&quot;not a sentence&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb133"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb133-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> sentenceType <span class="st">&quot;This is Haskell.&quot;</span></a>
+<a class="sourceLine" id="cb133-2" title="2"><span class="st">&quot;statement&quot;</span></a>
+<a class="sourceLine" id="cb133-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> sentenceType <span class="st">&quot;This is Haskell!&quot;</span></a>
+<a class="sourceLine" id="cb133-4" title="4"><span class="st">&quot;exclamation&quot;</span></a></code></pre></div>
 <h2 id="recap-pattern-matching"><span class="header-section-number">2.10</span> Recap: Pattern Matching</h2>
 <p>Things you can use as patterns:</p>
 <ul>
@@ -1512,33 +1510,33 @@ lectureParticipants = [Right 10, Right 13, Left &quot;easter vacation&quot;, Rig
 <ul>
 <li>Defining a function with equations:</li>
 </ul>
-<div class="sourceCode" id="cb134"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb134-1" data-line-number="1"><span class="ot">f ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb134-2" data-line-number="2">f <span class="dt">False</span> <span class="dt">Nothing</span>  <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb134-3" data-line-number="3">f <span class="dt">False</span> _        <span class="fu">=</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb134-4" data-line-number="4">f <span class="dt">True</span>  (<span class="dt">Just</span> i) <span class="fu">=</span> i</a>
-<a class="sourceLine" id="cb134-5" data-line-number="5">f <span class="dt">True</span>  <span class="dt">Nothing</span>  <span class="fu">=</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb134"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb134-1" title="1"><span class="ot">f ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb134-2" title="2">f <span class="dt">False</span> <span class="dt">Nothing</span>  <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb134-3" title="3">f <span class="dt">False</span> _        <span class="fu">=</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb134-4" title="4">f <span class="dt">True</span>  (<span class="dt">Just</span> i) <span class="fu">=</span> i</a>
+<a class="sourceLine" id="cb134-5" title="5">f <span class="dt">True</span>  <span class="dt">Nothing</span>  <span class="fu">=</span> <span class="dv">0</span></a></code></pre></div>
 <ul>
 <li>In the <code>case of</code> expression:</li>
 </ul>
-<div class="sourceCode" id="cb135"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb135-1" data-line-number="1"><span class="kw">case</span> number <span class="kw">of</span> <span class="dv">0</span> <span class="ot">-&gt;</span> <span class="st">&quot;zero&quot;</span></a>
-<a class="sourceLine" id="cb135-2" data-line-number="2">               <span class="dv">1</span> <span class="ot">-&gt;</span> <span class="st">&quot;one&quot;</span></a>
-<a class="sourceLine" id="cb135-3" data-line-number="3">               _ <span class="ot">-&gt;</span> <span class="st">&quot;not zero or one&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb135"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb135-1" title="1"><span class="kw">case</span> number <span class="kw">of</span> <span class="dv">0</span> <span class="ot">-&gt;</span> <span class="st">&quot;zero&quot;</span></a>
+<a class="sourceLine" id="cb135-2" title="2">               <span class="dv">1</span> <span class="ot">-&gt;</span> <span class="st">&quot;one&quot;</span></a>
+<a class="sourceLine" id="cb135-3" title="3">               _ <span class="ot">-&gt;</span> <span class="st">&quot;not zero or one&quot;</span></a></code></pre></div>
 <p>The only thing you really <em>need</em> pattern matching for is <em>getting the value</em> inside a <code>Just</code>, <code>Left</code> or <code>Right</code> constructor. Here are two more examples of this:</p>
-<div class="sourceCode" id="cb136"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb136-1" data-line-number="1"><span class="co">-- getElement (Just i) gets the ith element (counting from zero) of a list, getElement Nothing gets the last element</span></a>
-<a class="sourceLine" id="cb136-2" data-line-number="2"><span class="ot">getElement ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb136-3" data-line-number="3">getElement (<span class="dt">Just</span> i) xs <span class="fu">=</span> xs <span class="fu">!!</span> i</a>
-<a class="sourceLine" id="cb136-4" data-line-number="4">getElement <span class="dt">Nothing</span> xs <span class="fu">=</span> last xs</a></code></pre></div>
-<div class="sourceCode" id="cb137"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb137-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> getElement <span class="dt">Nothing</span> <span class="st">&quot;hurray!&quot;</span></a>
-<a class="sourceLine" id="cb137-2" data-line-number="2"><span class="ch">&#39;!&#39;</span></a>
-<a class="sourceLine" id="cb137-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> getElement (<span class="dt">Just</span> <span class="dv">3</span>) [<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>]</a>
-<a class="sourceLine" id="cb137-4" data-line-number="4"><span class="dv">8</span></a></code></pre></div>
-<div class="sourceCode" id="cb138"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb138-1" data-line-number="1"><span class="ot">direction ::</span> <span class="dt">Either</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb138-2" data-line-number="2">direction (<span class="dt">Left</span> i) <span class="fu">=</span> <span class="st">&quot;you should go left &quot;</span> <span class="fu">++</span> show i <span class="fu">++</span> <span class="st">&quot; meters!&quot;</span></a>
-<a class="sourceLine" id="cb138-3" data-line-number="3">direction (<span class="dt">Right</span> i) <span class="fu">=</span> <span class="st">&quot;you should go right &quot;</span> <span class="fu">++</span> show i <span class="fu">++</span> <span class="st">&quot; meters!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb139"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb139-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> direction (<span class="dt">Left</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb139-2" data-line-number="2"><span class="st">&quot;you should go left 3 meters!&quot;</span></a>
-<a class="sourceLine" id="cb139-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> direction (<span class="dt">Right</span> <span class="dv">5</span>)</a>
-<a class="sourceLine" id="cb139-4" data-line-number="4"><span class="st">&quot;you should go right 5 meters!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb136"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb136-1" title="1"><span class="co">-- getElement (Just i) gets the ith element (counting from zero) of a list, getElement Nothing gets the last element</span></a>
+<a class="sourceLine" id="cb136-2" title="2"><span class="ot">getElement ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb136-3" title="3">getElement (<span class="dt">Just</span> i) xs <span class="fu">=</span> xs <span class="fu">!!</span> i</a>
+<a class="sourceLine" id="cb136-4" title="4">getElement <span class="dt">Nothing</span> xs <span class="fu">=</span> <span class="fu">last</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb137"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb137-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> getElement <span class="dt">Nothing</span> <span class="st">&quot;hurray!&quot;</span></a>
+<a class="sourceLine" id="cb137-2" title="2"><span class="ch">&#39;!&#39;</span></a>
+<a class="sourceLine" id="cb137-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> getElement (<span class="dt">Just</span> <span class="dv">3</span>) [<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>]</a>
+<a class="sourceLine" id="cb137-4" title="4"><span class="dv">8</span></a></code></pre></div>
+<div class="sourceCode" id="cb138"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb138-1" title="1"><span class="ot">direction ::</span> <span class="dt">Either</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb138-2" title="2">direction (<span class="dt">Left</span> i) <span class="fu">=</span> <span class="st">&quot;you should go left &quot;</span> <span class="fu">++</span> <span class="fu">show</span> i <span class="fu">++</span> <span class="st">&quot; meters!&quot;</span></a>
+<a class="sourceLine" id="cb138-3" title="3">direction (<span class="dt">Right</span> i) <span class="fu">=</span> <span class="st">&quot;you should go right &quot;</span> <span class="fu">++</span> <span class="fu">show</span> i <span class="fu">++</span> <span class="st">&quot; meters!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb139"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb139-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> direction (<span class="dt">Left</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb139-2" title="2"><span class="st">&quot;you should go left 3 meters!&quot;</span></a>
+<a class="sourceLine" id="cb139-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> direction (<span class="dt">Right</span> <span class="dv">5</span>)</a>
+<a class="sourceLine" id="cb139-4" title="4"><span class="st">&quot;you should go right 5 meters!&quot;</span></a></code></pre></div>
 <p>Other uses (that we’ve seen so far!) of pattern matching can also be accomplished with the <code>==</code> operator. However, things like <code>x==Nothing</code> won’t work in all cases. We’ll find out why when we talk about type classes in lecture 4.</p>
 <h2 id="quiz-1"><span class="header-section-number">2.11</span> Quiz</h2>
 <p>How many values does <code>f x = [x,x]</code> return?</p>
@@ -1617,104 +1615,104 @@ Because <code>Nothing</code> is a constructor
 <h2 id="functional-programming-at-last"><span class="header-section-number">3.1</span> Functional Programming, at Last</h2>
 <p>Now with lists and polymorphism in our toolbox, we can finally start to look at functional programming.</p>
 <p>In Haskell a function is a value, just like a number or a list is. Functions can be passed as parameters to other functions. Here’s a toy example. The function <code>applyTo1</code> takes a function of type <code>Int-&gt;Int</code>, applies it to the number <code>1</code>, and returns the result.</p>
-<div class="sourceCode" id="cb140"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb140-1" data-line-number="1"><span class="ot">applyTo1 ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb140-2" data-line-number="2">applyTo1 f <span class="fu">=</span> f <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb140"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb140-1" title="1"><span class="ot">applyTo1 ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb140-2" title="2">applyTo1 f <span class="fu">=</span> f <span class="dv">1</span></a></code></pre></div>
 <p>Let’s define a simple function of type <code>Int-&gt;Int</code> and see <code>applyTo1</code> in action.</p>
-<div class="sourceCode" id="cb141"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb141-1" data-line-number="1"><span class="ot">addThree ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb141-2" data-line-number="2">addThree x <span class="fu">=</span> x <span class="fu">+</span> <span class="dv">3</span></a></code></pre></div>
-<div class="sourceCode" id="cb142"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb142-1" data-line-number="1">applyTo1 addThree</a>
-<a class="sourceLine" id="cb142-2" data-line-number="2">  <span class="fu">==&gt;</span> addThree <span class="dv">1</span></a>
-<a class="sourceLine" id="cb142-3" data-line-number="3">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb142-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
+<div class="sourceCode" id="cb141"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb141-1" title="1"><span class="ot">addThree ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb141-2" title="2">addThree x <span class="fu">=</span> x <span class="fu">+</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb142"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb142-1" title="1">applyTo1 addThree</a>
+<a class="sourceLine" id="cb142-2" title="2">  <span class="fu">==&gt;</span> addThree <span class="dv">1</span></a>
+<a class="sourceLine" id="cb142-3" title="3">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb142-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
 <p>Let’s go back to the type annotation for <code>applyTo1</code>.</p>
-<div class="sourceCode" id="cb143"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb143-1" data-line-number="1"><span class="ot">applyTo1 ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb143"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb143-1" title="1"><span class="ot">applyTo1 ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
 <p>The parentheses are needed because the type <code>Int -&gt; Int -&gt; Int</code> would be the type of a function taking two <code>Int</code> arguments. More on this later.</p>
 <p>Let’s look at a slightly more interesting example. This time we’ll implement a polymorphic function <code>doTwice</code>. Note how we can use it with various types of values and functions.</p>
-<div class="sourceCode" id="cb144"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb144-1" data-line-number="1"><span class="ot">doTwice ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb144-2" data-line-number="2">doTwice f x <span class="fu">=</span> f (f x)</a></code></pre></div>
-<div class="sourceCode" id="cb145"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb145-1" data-line-number="1">doTwice addThree <span class="dv">1</span></a>
-<a class="sourceLine" id="cb145-2" data-line-number="2">  <span class="fu">==&gt;</span> addThree (addThree <span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb145-3" data-line-number="3">  <span class="fu">==&gt;</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb145-4" data-line-number="4">doTwice tail <span class="st">&quot;abcd&quot;</span></a>
-<a class="sourceLine" id="cb145-5" data-line-number="5">  <span class="fu">==&gt;</span> tail (tail <span class="st">&quot;abcd&quot;</span>)</a>
-<a class="sourceLine" id="cb145-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="st">&quot;cd&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb146"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb146-1" data-line-number="1"><span class="ot">makeCool ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb146-2" data-line-number="2">makeCool str <span class="fu">=</span> <span class="st">&quot;WOW &quot;</span> <span class="fu">++</span> str <span class="fu">++</span> <span class="st">&quot;!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb147"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb147-1" data-line-number="1">doTwice makeCool <span class="st">&quot;Haskell&quot;</span></a>
-<a class="sourceLine" id="cb147-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="st">&quot;WOW WOW Haskell!!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb144"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb144-1" title="1"><span class="ot">doTwice ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb144-2" title="2">doTwice f x <span class="fu">=</span> f (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb145"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb145-1" title="1">doTwice addThree <span class="dv">1</span></a>
+<a class="sourceLine" id="cb145-2" title="2">  <span class="fu">==&gt;</span> addThree (addThree <span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb145-3" title="3">  <span class="fu">==&gt;</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb145-4" title="4">doTwice <span class="fu">tail</span> <span class="st">&quot;abcd&quot;</span></a>
+<a class="sourceLine" id="cb145-5" title="5">  <span class="fu">==&gt;</span> <span class="fu">tail</span> (<span class="fu">tail</span> <span class="st">&quot;abcd&quot;</span>)</a>
+<a class="sourceLine" id="cb145-6" title="6">  <span class="fu">==&gt;</span> <span class="st">&quot;cd&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb146"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb146-1" title="1"><span class="ot">makeCool ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb146-2" title="2">makeCool str <span class="fu">=</span> <span class="st">&quot;WOW &quot;</span> <span class="fu">++</span> str <span class="fu">++</span> <span class="st">&quot;!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb147"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb147-1" title="1">doTwice makeCool <span class="st">&quot;Haskell&quot;</span></a>
+<a class="sourceLine" id="cb147-2" title="2">  <span class="fu">==&gt;</span> <span class="st">&quot;WOW WOW Haskell!!&quot;</span></a></code></pre></div>
 <h3 id="functional-programming-on-lists"><span class="header-section-number">3.1.1</span> Functional Programming on Lists</h3>
 <p>That was a bit boring. Luckily there are many useful list functions that take functions as arguments. By the way, functions that take functions as arguments (or return functions) are often called <em>higher-order functions</em>.</p>
 <p>The most famous of these list-processing higher-order functions is <code>map</code>. It gives you a new list by applying the given function to all elements of a list.</p>
-<div class="sourceCode" id="cb148"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb148-1" data-line-number="1">map<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a></code></pre></div>
-<div class="sourceCode" id="cb149"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb149-1" data-line-number="1">map addThree [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb149-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb148"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb148-1" title="1"><span class="fu">map</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a></code></pre></div>
+<div class="sourceCode" id="cb149"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb149-1" title="1"><span class="fu">map</span> addThree [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb149-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>]</a></code></pre></div>
 <p>The partner in crime for <code>map</code> is <code>filter</code>. Instead of transforming all elements of a list, <code>filter</code> drops some elements of a list and keeps others. In other words, <code>filter</code> selects the elements from a list that fulfill a condition.</p>
-<div class="sourceCode" id="cb150"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb150-1" data-line-number="1">filter<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb150"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb150-1" title="1"><span class="fu">filter</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>Here’s an example: selecting the positive elements from a list</p>
-<div class="sourceCode" id="cb151"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb151-1" data-line-number="1"><span class="ot">positive ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb151-2" data-line-number="2">positive x <span class="fu">=</span> x<span class="fu">&gt;</span><span class="dv">0</span></a></code></pre></div>
-<div class="sourceCode" id="cb152"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb152-1" data-line-number="1">filter positive [<span class="dv">0</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb152-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb151"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb151-1" title="1"><span class="ot">positive ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb151-2" title="2">positive x <span class="fu">=</span> x<span class="fu">&gt;</span><span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb152"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb152-1" title="1"><span class="fu">filter</span> positive [<span class="dv">0</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb152-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>Note how both the type signatures of <code>map</code> and <code>filter</code> use polymorphism. They work on all kinds of lists. The type of <code>map</code> even uses two type parameters! Here are some examples of type inference using <code>map</code> and <code>filter</code>.</p>
-<div class="sourceCode" id="cb153"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb153-1" data-line-number="1">onlyPositive xs <span class="fu">=</span> filter positive xs</a>
-<a class="sourceLine" id="cb153-2" data-line-number="2">mapBooleans f <span class="fu">=</span> map f [<span class="dt">False</span>,<span class="dt">True</span>]</a></code></pre></div>
-<div class="sourceCode" id="cb154"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb154-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t onlyPositive</a>
-<a class="sourceLine" id="cb154-2" data-line-number="2"><span class="ot">onlyPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb154-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t mapBooleans</a>
-<a class="sourceLine" id="cb154-4" data-line-number="4"><span class="ot">mapBooleans ::</span> (<span class="dt">Bool</span> <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb154-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t mapBooleans not</a>
-<a class="sourceLine" id="cb154-6" data-line-number="6">mapBooleans<span class="ot"> not ::</span> [<span class="dt">Bool</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb153"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb153-1" title="1">onlyPositive xs <span class="fu">=</span> <span class="fu">filter</span> positive xs</a>
+<a class="sourceLine" id="cb153-2" title="2">mapBooleans f <span class="fu">=</span> <span class="fu">map</span> f [<span class="dt">False</span>,<span class="dt">True</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb154"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb154-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t onlyPositive</a>
+<a class="sourceLine" id="cb154-2" title="2"><span class="ot">onlyPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb154-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t mapBooleans</a>
+<a class="sourceLine" id="cb154-4" title="4"><span class="ot">mapBooleans ::</span> (<span class="dt">Bool</span> <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb154-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t mapBooleans <span class="fu">not</span></a>
+<a class="sourceLine" id="cb154-6" title="6">mapBooleans<span class="ot"> not ::</span> [<span class="dt">Bool</span>]</a></code></pre></div>
 <p>One more thing: remember how constructors were just functions? That means you can pass them as arguments to other functions!</p>
-<div class="sourceCode" id="cb155"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb155-1" data-line-number="1">wrapJust xs <span class="fu">=</span> map <span class="dt">Just</span> xs</a></code></pre></div>
-<div class="sourceCode" id="cb156"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb156-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t wrapJust</a>
-<a class="sourceLine" id="cb156-2" data-line-number="2"><span class="ot">wrapJust ::</span> [a] <span class="ot">-&gt;</span> [<span class="dt">Maybe</span> a]</a>
-<a class="sourceLine" id="cb156-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> wrapJust [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb156-4" data-line-number="4">[<span class="dt">Just</span> <span class="dv">1</span>,<span class="dt">Just</span> <span class="dv">2</span>,<span class="dt">Just</span> <span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb155"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb155-1" title="1">wrapJust xs <span class="fu">=</span> <span class="fu">map</span> <span class="dt">Just</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb156"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb156-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t wrapJust</a>
+<a class="sourceLine" id="cb156-2" title="2"><span class="ot">wrapJust ::</span> [a] <span class="ot">-&gt;</span> [<span class="dt">Maybe</span> a]</a>
+<a class="sourceLine" id="cb156-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> wrapJust [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb156-4" title="4">[<span class="dt">Just</span> <span class="dv">1</span>,<span class="dt">Just</span> <span class="dv">2</span>,<span class="dt">Just</span> <span class="dv">3</span>]</a></code></pre></div>
 <h3 id="examples-of-functional-programming-on-lists"><span class="header-section-number">3.1.2</span> Examples of Functional Programming on Lists</h3>
 <p>How many “palindrome numbers” are between <code>1</code> and <code>n</code>?</p>
-<div class="sourceCode" id="cb157"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb157-1" data-line-number="1"><span class="co">-- a predicate that checks if a string is a palindrome</span></a>
-<a class="sourceLine" id="cb157-2" data-line-number="2"><span class="ot">palindrome ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb157-3" data-line-number="3">palindrome str <span class="fu">=</span> str <span class="fu">==</span> reverse str</a>
-<a class="sourceLine" id="cb157-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb157-5" data-line-number="5"><span class="co">-- palindromes n takes all numbers from 1 to n, converts them to strings using show, and keeps only palindromes</span></a>
-<a class="sourceLine" id="cb157-6" data-line-number="6"><span class="ot">palindromes ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb157-7" data-line-number="7">palindromes n <span class="fu">=</span> filter palindrome (map show [<span class="dv">1</span><span class="fu">..</span>n])</a></code></pre></div>
-<div class="sourceCode" id="cb158"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb158-1" data-line-number="1">palindrome <span class="st">&quot;1331&quot;</span> <span class="fu">==&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb158-2" data-line-number="2">palindromes <span class="dv">150</span> <span class="fu">==&gt;</span></a>
-<a class="sourceLine" id="cb158-3" data-line-number="3">  [<span class="st">&quot;1&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;3&quot;</span>,<span class="st">&quot;4&quot;</span>,<span class="st">&quot;5&quot;</span>,<span class="st">&quot;6&quot;</span>,<span class="st">&quot;7&quot;</span>,<span class="st">&quot;8&quot;</span>,<span class="st">&quot;9&quot;</span>,</a>
-<a class="sourceLine" id="cb158-4" data-line-number="4">   <span class="st">&quot;11&quot;</span>,<span class="st">&quot;22&quot;</span>,<span class="st">&quot;33&quot;</span>,<span class="st">&quot;44&quot;</span>,<span class="st">&quot;55&quot;</span>,<span class="st">&quot;66&quot;</span>,<span class="st">&quot;77&quot;</span>,<span class="st">&quot;88&quot;</span>,<span class="st">&quot;99&quot;</span>,</a>
-<a class="sourceLine" id="cb158-5" data-line-number="5">   <span class="st">&quot;101&quot;</span>,<span class="st">&quot;111&quot;</span>,<span class="st">&quot;121&quot;</span>,<span class="st">&quot;131&quot;</span>,<span class="st">&quot;141&quot;</span>]</a>
-<a class="sourceLine" id="cb158-6" data-line-number="6">length (palindromes <span class="dv">9999</span>) <span class="fu">==&gt;</span> <span class="dv">198</span></a></code></pre></div>
+<div class="sourceCode" id="cb157"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb157-1" title="1"><span class="co">-- a predicate that checks if a string is a palindrome</span></a>
+<a class="sourceLine" id="cb157-2" title="2"><span class="ot">palindrome ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb157-3" title="3">palindrome str <span class="fu">=</span> str <span class="fu">==</span> <span class="fu">reverse</span> str</a>
+<a class="sourceLine" id="cb157-4" title="4"></a>
+<a class="sourceLine" id="cb157-5" title="5"><span class="co">-- palindromes n takes all numbers from 1 to n, converts them to strings using show, and keeps only palindromes</span></a>
+<a class="sourceLine" id="cb157-6" title="6"><span class="ot">palindromes ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb157-7" title="7">palindromes n <span class="fu">=</span> <span class="fu">filter</span> palindrome (<span class="fu">map</span> <span class="fu">show</span> [<span class="dv">1</span><span class="fu">..</span>n])</a></code></pre></div>
+<div class="sourceCode" id="cb158"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb158-1" title="1">palindrome <span class="st">&quot;1331&quot;</span> <span class="fu">==&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb158-2" title="2">palindromes <span class="dv">150</span> <span class="fu">==&gt;</span></a>
+<a class="sourceLine" id="cb158-3" title="3">  [<span class="st">&quot;1&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;3&quot;</span>,<span class="st">&quot;4&quot;</span>,<span class="st">&quot;5&quot;</span>,<span class="st">&quot;6&quot;</span>,<span class="st">&quot;7&quot;</span>,<span class="st">&quot;8&quot;</span>,<span class="st">&quot;9&quot;</span>,</a>
+<a class="sourceLine" id="cb158-4" title="4">   <span class="st">&quot;11&quot;</span>,<span class="st">&quot;22&quot;</span>,<span class="st">&quot;33&quot;</span>,<span class="st">&quot;44&quot;</span>,<span class="st">&quot;55&quot;</span>,<span class="st">&quot;66&quot;</span>,<span class="st">&quot;77&quot;</span>,<span class="st">&quot;88&quot;</span>,<span class="st">&quot;99&quot;</span>,</a>
+<a class="sourceLine" id="cb158-5" title="5">   <span class="st">&quot;101&quot;</span>,<span class="st">&quot;111&quot;</span>,<span class="st">&quot;121&quot;</span>,<span class="st">&quot;131&quot;</span>,<span class="st">&quot;141&quot;</span>]</a>
+<a class="sourceLine" id="cb158-6" title="6"><span class="fu">length</span> (palindromes <span class="dv">9999</span>) <span class="fu">==&gt;</span> <span class="dv">198</span></a></code></pre></div>
 <p>How many words in a string start with “a”? This uses the function <code>words</code> from the module <code>Data.List</code> that splits a string into words.</p>
-<div class="sourceCode" id="cb159"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb159-1" data-line-number="1"><span class="ot">countAWords ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb159-2" data-line-number="2">countAWords string <span class="fu">=</span> length (filter startsWithA (words string))</a>
-<a class="sourceLine" id="cb159-3" data-line-number="3">  <span class="kw">where</span> startsWithA s <span class="fu">=</span> head s <span class="fu">==</span> <span class="ch">&#39;a&#39;</span></a></code></pre></div>
-<div class="sourceCode" id="cb160"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb160-1" data-line-number="1">countAWords <span class="st">&quot;does anyone want an apple?&quot;</span></a>
-<a class="sourceLine" id="cb160-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb159"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb159-1" title="1"><span class="ot">countAWords ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb159-2" title="2">countAWords string <span class="fu">=</span> <span class="fu">length</span> (<span class="fu">filter</span> startsWithA (<span class="fu">words</span> string))</a>
+<a class="sourceLine" id="cb159-3" title="3">  <span class="kw">where</span> startsWithA s <span class="fu">=</span> <span class="fu">head</span> s <span class="fu">==</span> <span class="ch">&#39;a&#39;</span></a></code></pre></div>
+<div class="sourceCode" id="cb160"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb160-1" title="1">countAWords <span class="st">&quot;does anyone want an apple?&quot;</span></a>
+<a class="sourceLine" id="cb160-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>The function <code>tails</code> from <code>Data.List</code> returns the list of all suffixes (“tails”) of a list. We can use <code>tails</code> for many string processing tasks. Here’s how <code>tails</code> works:</p>
-<div class="sourceCode" id="cb161"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb161-1" data-line-number="1">tails <span class="st">&quot;echo&quot;</span></a>
-<a class="sourceLine" id="cb161-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;echo&quot;</span>,<span class="st">&quot;cho&quot;</span>,<span class="st">&quot;ho&quot;</span>,<span class="st">&quot;o&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb161"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb161-1" title="1">tails <span class="st">&quot;echo&quot;</span></a>
+<a class="sourceLine" id="cb161-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;echo&quot;</span>,<span class="st">&quot;cho&quot;</span>,<span class="st">&quot;ho&quot;</span>,<span class="st">&quot;o&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
 <p>Here’s an example where we find what characters come after a given character in a string. First of all, we use <code>tails</code>, <code>map</code> and <code>take</code> to get all substrings of a certain length:</p>
-<div class="sourceCode" id="cb162"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb162-1" data-line-number="1"><span class="ot">substringsOfLength ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb162-2" data-line-number="2">substringsOfLength n string <span class="fu">=</span> map shorten (tails string)</a>
-<a class="sourceLine" id="cb162-3" data-line-number="3">  <span class="kw">where</span> shorten s <span class="fu">=</span> take n s</a></code></pre></div>
-<div class="sourceCode" id="cb163"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb163-1" data-line-number="1">substringsOfLength <span class="dv">3</span> <span class="st">&quot;hello&quot;</span></a>
-<a class="sourceLine" id="cb163-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;hel&quot;</span>,<span class="st">&quot;ell&quot;</span>,<span class="st">&quot;llo&quot;</span>,<span class="st">&quot;lo&quot;</span>,<span class="st">&quot;o&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb162"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb162-1" title="1"><span class="ot">substringsOfLength ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb162-2" title="2">substringsOfLength n string <span class="fu">=</span> <span class="fu">map</span> shorten (tails string)</a>
+<a class="sourceLine" id="cb162-3" title="3">  <span class="kw">where</span> shorten s <span class="fu">=</span> <span class="fu">take</span> n s</a></code></pre></div>
+<div class="sourceCode" id="cb163"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb163-1" title="1">substringsOfLength <span class="dv">3</span> <span class="st">&quot;hello&quot;</span></a>
+<a class="sourceLine" id="cb163-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;hel&quot;</span>,<span class="st">&quot;ell&quot;</span>,<span class="st">&quot;llo&quot;</span>,<span class="st">&quot;lo&quot;</span>,<span class="st">&quot;o&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
 <p>There’s some shorter substrings left at the end (can you see why?), but they’re fine for our purposes right now. Now that we have <code>substringsOfLength</code>, we can implement the function <code>whatFollows c k s</code> that finds all the occurrences of the character <code>c</code> in the string <code>s</code>, and outputs the <code>k</code> letters that come after these occurrences.</p>
-<div class="sourceCode" id="cb164"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb164-1" data-line-number="1"><span class="ot">whatFollows ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb164-2" data-line-number="2">whatFollows c k string <span class="fu">=</span> map tail (filter match (substringsOfLength (k<span class="fu">+</span><span class="dv">1</span>) string))</a>
-<a class="sourceLine" id="cb164-3" data-line-number="3">  <span class="kw">where</span> match sub <span class="fu">=</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
-<div class="sourceCode" id="cb165"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb165-1" data-line-number="1">whatFollows <span class="ch">&#39;a&#39;</span> <span class="dv">2</span> <span class="st">&quot;abracadabra&quot;</span></a>
-<a class="sourceLine" id="cb165-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;br&quot;</span>,<span class="st">&quot;ca&quot;</span>,<span class="st">&quot;da&quot;</span>,<span class="st">&quot;br&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb164"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb164-1" title="1"><span class="ot">whatFollows ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb164-2" title="2">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> (<span class="fu">filter</span> match (substringsOfLength (k<span class="fu">+</span><span class="dv">1</span>) string))</a>
+<a class="sourceLine" id="cb164-3" title="3">  <span class="kw">where</span> match sub <span class="fu">=</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb165"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb165-1" title="1">whatFollows <span class="ch">&#39;a&#39;</span> <span class="dv">2</span> <span class="st">&quot;abracadabra&quot;</span></a>
+<a class="sourceLine" id="cb165-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;br&quot;</span>,<span class="st">&quot;ca&quot;</span>,<span class="st">&quot;da&quot;</span>,<span class="st">&quot;br&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
 <h2 id="partial-application"><span class="header-section-number">3.2</span> Partial Application</h2>
 <p>When using higher-order functions you can find yourself defining lots of small helper functions, like <code>addThree</code> or <code>shorten</code> in the previous examples. This is a bit of a chore in the long run, but luckily Haskell’s functions behave a bit weirdly…</p>
 <p>Let’s start in GHCi:</p>
-<div class="sourceCode" id="cb166"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb166-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> add a b <span class="fu">=</span> a<span class="fu">+</span>b</a>
-<a class="sourceLine" id="cb166-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> add <span class="dv">1</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb166-3" data-line-number="3"><span class="dv">6</span></a>
-<a class="sourceLine" id="cb166-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> addThree <span class="fu">=</span> add <span class="dv">3</span></a>
-<a class="sourceLine" id="cb166-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> addThree <span class="dv">2</span></a>
-<a class="sourceLine" id="cb166-6" data-line-number="6"><span class="dv">5</span></a></code></pre></div>
+<div class="sourceCode" id="cb166"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb166-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> add a b <span class="fu">=</span> a<span class="fu">+</span>b</a>
+<a class="sourceLine" id="cb166-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> add <span class="dv">1</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb166-3" title="3"><span class="dv">6</span></a>
+<a class="sourceLine" id="cb166-4" title="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> addThree <span class="fu">=</span> add <span class="dv">3</span></a>
+<a class="sourceLine" id="cb166-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> addThree <span class="dv">2</span></a>
+<a class="sourceLine" id="cb166-6" title="6"><span class="dv">5</span></a></code></pre></div>
 <p>So, we’ve defined <code>add</code>, a function of two arguments, and only given it one argument. The result is not a type error but a new function. The new function just stores (or remembers) the given argument, waits for another argument, and then gives both to <code>add</code>.</p>
 <pre><code>Prelude&gt; map addThree [1,2,3]
 [4,5,6]
@@ -1722,210 +1720,210 @@ Prelude&gt; map (add 3) [1,2,3]
 [4,5,6]</code></pre>
 <p>Here we can see that we don’t even need to give a name to the function returned by <code>add 3</code>. We can just use it anywhere where a function of one argument is expected.</p>
 <p>This is called <em>partial application</em>. All functions in Haskell behave like this. Let’s have a closer look. Here’s a function that takes many arguments.</p>
-<div class="sourceCode" id="cb168"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb168-1" data-line-number="1"><span class="ot">between ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb168-2" data-line-number="2">between lo high x <span class="fu">=</span> x <span class="fu">&lt;</span> high <span class="fu">&amp;&amp;</span> x <span class="fu">&gt;</span> lo</a></code></pre></div>
-<div class="sourceCode" id="cb169"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb169-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> between <span class="dv">3</span> <span class="dv">7</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb169-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb169-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> between <span class="dv">3</span> <span class="dv">6</span> <span class="dv">8</span></a>
-<a class="sourceLine" id="cb169-4" data-line-number="4"><span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb168"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb168-1" title="1"><span class="ot">between ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb168-2" title="2">between lo high x <span class="fu">=</span> x <span class="fu">&lt;</span> high <span class="fu">&amp;&amp;</span> x <span class="fu">&gt;</span> lo</a></code></pre></div>
+<div class="sourceCode" id="cb169"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb169-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> between <span class="dv">3</span> <span class="dv">7</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb169-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb169-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> between <span class="dv">3</span> <span class="dv">6</span> <span class="dv">8</span></a>
+<a class="sourceLine" id="cb169-4" title="4"><span class="dt">False</span></a></code></pre></div>
 <p>We can give <code>between</code> less arguments and get back new functions, just like we saw with <code>add</code>:</p>
-<div class="sourceCode" id="cb170"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb170-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> (between <span class="dv">1</span> <span class="dv">5</span>) <span class="dv">2</span></a>
-<a class="sourceLine" id="cb170-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb170-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f <span class="fu">=</span> between <span class="dv">1</span> <span class="dv">5</span> <span class="kw">in</span> f <span class="dv">2</span></a>
-<a class="sourceLine" id="cb170-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb170-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> map (between <span class="dv">1</span> <span class="dv">3</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb170-6" data-line-number="6">[<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb170"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb170-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> (between <span class="dv">1</span> <span class="dv">5</span>) <span class="dv">2</span></a>
+<a class="sourceLine" id="cb170-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb170-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f <span class="fu">=</span> between <span class="dv">1</span> <span class="dv">5</span> <span class="kw">in</span> f <span class="dv">2</span></a>
+<a class="sourceLine" id="cb170-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb170-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> (between <span class="dv">1</span> <span class="dv">3</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb170-6" title="6">[<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]</a></code></pre></div>
 <p>Look at the types of partially applying <code>between</code>. They behave neatly, with arguments disappearing one by one from the type as values are added to the expression.</p>
-<div class="sourceCode" id="cb171"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb171-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between</a>
-<a class="sourceLine" id="cb171-2" data-line-number="2"><span class="ot">between ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb171-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span></a>
-<a class="sourceLine" id="cb171-4" data-line-number="4">between <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb171-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb171-6" data-line-number="6">between <span class="dv">1</span> <span class="dv">2</span><span class="ot"> ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb171-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span> <span class="dv">2</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb171-8" data-line-number="8">between <span class="dv">1</span> <span class="dv">2</span> <span class="dv">3</span><span class="ot"> ::</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb171"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb171-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between</a>
+<a class="sourceLine" id="cb171-2" title="2"><span class="ot">between ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb171-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span></a>
+<a class="sourceLine" id="cb171-4" title="4">between <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb171-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb171-6" title="6">between <span class="dv">1</span> <span class="dv">2</span><span class="ot"> ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb171-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t between <span class="dv">1</span> <span class="dv">2</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb171-8" title="8">between <span class="dv">1</span> <span class="dv">2</span> <span class="dv">3</span><span class="ot"> ::</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>Actually, when we write a type like <code>Integer -&gt; Integer -&gt; Integer -&gt; Bool</code>, it means <code>Integer -&gt; (Integer -&gt; (Integer -&gt; Bool))</code>. That is, a multi-argument function is just a function that returns a function. Similarly, an expression like <code>between 1 2 3</code> is the same as <code>((between 1) 2) 3</code>, so passing multiple arguments to a function happens via multiple single-argument calls. Representing multi-argument functions like this is called <em>currying</em> (after the logician Haskell Curry). Currying is what makes partial application possible.</p>
 <p>Here’s another example of using partial application with <code>map</code>:</p>
-<div class="sourceCode" id="cb172"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb172-1" data-line-number="1">map (drop <span class="dv">1</span>) [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World!&quot;</span>]</a>
-<a class="sourceLine" id="cb172-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;ello&quot;</span>,<span class="st">&quot;orld!&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb172"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb172-1" title="1"><span class="fu">map</span> (<span class="fu">drop</span> <span class="dv">1</span>) [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World!&quot;</span>]</a>
+<a class="sourceLine" id="cb172-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;ello&quot;</span>,<span class="st">&quot;orld!&quot;</span>]</a></code></pre></div>
 <p>In addition to normal functions, partial application also works with operators. With operators you can choose whether you apply the left or the right argument. (Partially applied operators are also called <em>sections</em> or <em>operator sections</em>). Some examples:</p>
-<div class="sourceCode" id="cb173"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb173-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> map (<span class="fu">*</span><span class="dv">2</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb173-2" data-line-number="2">[<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb173-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> map (<span class="dv">2</span><span class="fu">*</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb173-4" data-line-number="4">[<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb173-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> map (<span class="dv">1</span><span class="fu">/</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]</a>
-<a class="sourceLine" id="cb173-6" data-line-number="6">[<span class="fl">1.0</span>,<span class="fl">0.5</span>,<span class="fl">0.3333333333333333</span>,<span class="fl">0.25</span>,<span class="fl">0.2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb173"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb173-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> (<span class="fu">*</span><span class="dv">2</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb173-2" title="2">[<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb173-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> (<span class="dv">2</span><span class="fu">*</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb173-4" title="4">[<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb173-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> (<span class="dv">1</span><span class="fu">/</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]</a>
+<a class="sourceLine" id="cb173-6" title="6">[<span class="fl">1.0</span>,<span class="fl">0.5</span>,<span class="fl">0.3333333333333333</span>,<span class="fl">0.25</span>,<span class="fl">0.2</span>]</a></code></pre></div>
 <h2 id="prefix-and-infix-notations"><span class="header-section-number">3.3</span> Prefix and Infix Notations</h2>
 <p>Normal Haskell operators are applied with <em>prefix notation</em>, which is just a fancy way to say that the function name comes before the arguments. In contrast, operators are applied with <em>infix notation</em> – the name of the function comes between the arguments.</p>
 <p>An infix operator can be converted into a prefix function by adding parentheses around it. For instance,</p>
-<div class="sourceCode" id="cb174"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb174-1" data-line-number="1">(<span class="fu">+</span>) <span class="dv">1</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb174"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb174-1" title="1">(<span class="fu">+</span>) <span class="dv">1</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>This is useful especially when an operator needs to be passed as an argument to another function.</p>
 <p>As an example, the function <code>zipWith</code> takes two lists, a binary function, and joins the lists using the function. We can use <code>zipWith (+)</code> to sum two lists, element-by-element:</p>
-<div class="sourceCode" id="cb175"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb175-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t zipWith</a>
-<a class="sourceLine" id="cb175-2" data-line-number="2">zipWith<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a>
-<a class="sourceLine" id="cb175-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> zipWith (<span class="fu">+</span>) [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">5</span>] [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb175-4" data-line-number="4">[<span class="dv">1</span>,<span class="dv">5</span>,<span class="dv">8</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb175"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb175-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">zipWith</span></a>
+<a class="sourceLine" id="cb175-2" title="2"><span class="fu">zipWith</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a>
+<a class="sourceLine" id="cb175-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">zipWith</span> (<span class="fu">+</span>) [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">5</span>] [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb175-4" title="4">[<span class="dv">1</span>,<span class="dv">5</span>,<span class="dv">8</span>]</a></code></pre></div>
 <p>Without the ability to turn an operator into a function, we’d have to use a helper function – such as <code>add</code> above.</p>
 <p>Note that omitting the parentheses leads into a type error:</p>
-<div class="sourceCode" id="cb176"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb176-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> zipWith <span class="fu">+</span> [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">5</span>,<span class="dv">3</span>] [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb176-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb176-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">11</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb176-4" data-line-number="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘[<span class="dt">Integer</span>]</a>
-<a class="sourceLine" id="cb176-5" data-line-number="5">                                    <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]’</a>
-<a class="sourceLine" id="cb176-6" data-line-number="6">                  with actual <span class="kw">type</span> ‘[<span class="dt">Integer</span>]’</a>
-<a class="sourceLine" id="cb176-7" data-line-number="7">    • <span class="dt">The</span> function ‘[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>]’ is applied to one argument,</a>
-<a class="sourceLine" id="cb176-8" data-line-number="8">      but its <span class="kw">type</span> ‘[<span class="dt">Integer</span>]’ has none</a>
-<a class="sourceLine" id="cb176-9" data-line-number="9">      <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">+</span>)’, namely ‘[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>] [<span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">3</span>]’</a>
-<a class="sourceLine" id="cb176-10" data-line-number="10">      <span class="dt">In</span> the expression<span class="fu">:</span> zipWith <span class="fu">+</span> [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>] [<span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb176-11" data-line-number="11">    • <span class="dt">Relevant</span> bindings include</a>
-<a class="sourceLine" id="cb176-12" data-line-number="12"><span class="ot">        it ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a>
-<a class="sourceLine" id="cb176-13" data-line-number="13">          (bound at <span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb176"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb176-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">zipWith</span> <span class="fu">+</span> [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">5</span>,<span class="dv">3</span>] [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb176-2" title="2"></a>
+<a class="sourceLine" id="cb176-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">11</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb176-4" title="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘[<span class="dt">Integer</span>]</a>
+<a class="sourceLine" id="cb176-5" title="5">                                    <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]’</a>
+<a class="sourceLine" id="cb176-6" title="6">                  with actual <span class="kw">type</span> ‘[<span class="dt">Integer</span>]’</a>
+<a class="sourceLine" id="cb176-7" title="7">    • <span class="dt">The</span> function ‘[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>]’ is applied to one argument,</a>
+<a class="sourceLine" id="cb176-8" title="8">      but its <span class="kw">type</span> ‘[<span class="dt">Integer</span>]’ has none</a>
+<a class="sourceLine" id="cb176-9" title="9">      <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">+</span>)’, namely ‘[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>] [<span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">3</span>]’</a>
+<a class="sourceLine" id="cb176-10" title="10">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="fu">zipWith</span> <span class="fu">+</span> [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">3</span>] [<span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb176-11" title="11">    • <span class="dt">Relevant</span> bindings include</a>
+<a class="sourceLine" id="cb176-12" title="12"><span class="ot">        it ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a>
+<a class="sourceLine" id="cb176-13" title="13">          (bound at <span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span>)</a></code></pre></div>
 <p>The reason for this weird-looking error is that GHCi got confused and thought that we were somehow trying to add <code>zipWith</code> and <code>[0,2,5,3] [1,3,3]</code> together. Logically, it deduced that <code>[0,2,5,3]</code> must be a function since it’s being applied to <code>[1,3,3]</code> (remember that functions bind tighter than operators).</p>
 <p>Unfortunately, error messages can sometimes be obscure, since the compiler cannot always know the “real” cause of the error (which is in this case was omitting the parentheses). Weird error messages are frustrating, but only the programmer knows what was the original intent behind the code.</p>
 <p>Another nice feature of Haskell is the syntax for applying a binary function as if it was an infix operator, by surrounding it with backticks (`). For example:</p>
-<div class="sourceCode" id="cb177"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb177-1" data-line-number="1"><span class="dv">6</span> <span class="ot">`div`</span> <span class="dv">2</span> <span class="fu">==&gt;</span> div <span class="dv">6</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb177-2" data-line-number="2">(<span class="fu">+</span><span class="dv">1</span>) <span class="ot">`map`</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> map (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb177"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb177-1" title="1"><span class="dv">6</span> <span class="ot">`div`</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="fu">div</span> <span class="dv">6</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb177-2" title="2">(<span class="fu">+</span><span class="dv">1</span>) <span class="ot">`map`</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <h2 id="lambdas"><span class="header-section-number">3.4</span> Lambdas</h2>
 <p>The last spanner we need in our functional programming toolbox is λ (lambda). Lambda expressions are <em>anonymous functions</em>. Consider a situation where you need a function only once, for example in an expression like</p>
-<div class="sourceCode" id="cb178"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb178-1" data-line-number="1"><span class="kw">let</span> big x <span class="fu">=</span> x<span class="fu">&gt;</span><span class="dv">7</span> <span class="kw">in</span> filter big [<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">100</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb178"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb178-1" title="1"><span class="kw">let</span> big x <span class="fu">=</span> x<span class="fu">&gt;</span><span class="dv">7</span> <span class="kw">in</span> <span class="fu">filter</span> big [<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">100</span>]</a></code></pre></div>
 <p>A lambda expression allows us to write this directly, without defining a name (<code>big</code>) for the helper function:</p>
-<div class="sourceCode" id="cb179"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb179-1" data-line-number="1">filter (\x <span class="ot">-&gt;</span> x<span class="fu">&gt;</span><span class="dv">7</span>) [<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">100</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb179"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb179-1" title="1"><span class="fu">filter</span> (\x <span class="ot">-&gt;</span> x<span class="fu">&gt;</span><span class="dv">7</span>) [<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">100</span>]</a></code></pre></div>
 <p>Here are some more examples in GHCi:</p>
-<div class="sourceCode" id="cb180"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb180-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> x<span class="fu">*</span>x) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb180-2" data-line-number="2"><span class="dv">9</span></a>
-<a class="sourceLine" id="cb180-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> reverse x <span class="fu">==</span> x) <span class="st">&quot;ABBA&quot;</span></a>
-<a class="sourceLine" id="cb180-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb180-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> filter (\x <span class="ot">-&gt;</span> reverse x <span class="fu">==</span> x) [<span class="st">&quot;ABBA&quot;</span>,<span class="st">&quot;ACDC&quot;</span>,<span class="st">&quot;otto&quot;</span>,<span class="st">&quot;lothar&quot;</span>,<span class="st">&quot;anna&quot;</span>]</a>
-<a class="sourceLine" id="cb180-6" data-line-number="6">[<span class="st">&quot;ABBA&quot;</span>,<span class="st">&quot;otto&quot;</span>,<span class="st">&quot;anna&quot;</span>]</a>
-<a class="sourceLine" id="cb180-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x y <span class="ot">-&gt;</span> x<span class="fu">^</span><span class="dv">2</span><span class="fu">+</span>y<span class="fu">^</span><span class="dv">2</span>) <span class="dv">2</span> <span class="dv">3</span>           <span class="co">-- multiple arguments</span></a>
-<a class="sourceLine" id="cb180-8" data-line-number="8"><span class="dv">13</span></a></code></pre></div>
+<div class="sourceCode" id="cb180"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb180-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> x<span class="fu">*</span>x) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb180-2" title="2"><span class="dv">9</span></a>
+<a class="sourceLine" id="cb180-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> <span class="fu">reverse</span> x <span class="fu">==</span> x) <span class="st">&quot;ABBA&quot;</span></a>
+<a class="sourceLine" id="cb180-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb180-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">filter</span> (\x <span class="ot">-&gt;</span> <span class="fu">reverse</span> x <span class="fu">==</span> x) [<span class="st">&quot;ABBA&quot;</span>,<span class="st">&quot;ACDC&quot;</span>,<span class="st">&quot;otto&quot;</span>,<span class="st">&quot;lothar&quot;</span>,<span class="st">&quot;anna&quot;</span>]</a>
+<a class="sourceLine" id="cb180-6" title="6">[<span class="st">&quot;ABBA&quot;</span>,<span class="st">&quot;otto&quot;</span>,<span class="st">&quot;anna&quot;</span>]</a>
+<a class="sourceLine" id="cb180-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x y <span class="ot">-&gt;</span> x<span class="fu">^</span><span class="dv">2</span><span class="fu">+</span>y<span class="fu">^</span><span class="dv">2</span>) <span class="dv">2</span> <span class="dv">3</span>           <span class="co">-- multiple arguments</span></a>
+<a class="sourceLine" id="cb180-8" title="8"><span class="dv">13</span></a></code></pre></div>
 <p>The Haskell syntax for lambdas is a bit surprising. The backslash character (<code>\</code>) stands for the greek letter lambda (λ). The Haskell expression <code>\x -&gt; x+1</code> is trying to mimic the mathematical notation <em>λx. x+1</em>. Other languages use syntax like <code>x =&gt; x+1</code> (JavaScript) or <code>lambda x: x+1</code> (Python).</p>
 <p><strong>Note!</strong> You never <em>need</em> to use a lambda expression. You can always instead define the function normally using <code>let</code> or <code>where</code>.</p>
 <p>By the way, lambda expressions are quite powerful constructs which have a deep theory of their own, known as <a href="https://en.wikipedia.org/wiki/Lambda_calculus">Lambda calculus</a>. Some even consider purely functional programming languages such as Haskell to be typed extensions of Lambda calculus with extra syntax.</p>
 <h2 id="sidenote-the-.-and-operators"><span class="header-section-number">3.5</span> Sidenote: The <code>.</code> and <code>$</code> Operators</h2>
 <p>The two most common operators in Haskell codebases are probably <code>.</code> and <code>$</code>. They are useful when writing code that uses higher-order functions. The first of these, the <code>.</code> operator, is the <em>function composition</em> operator. Here’s its type</p>
-<div class="sourceCode" id="cb181"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb181-1" data-line-number="1"><span class="ot">(.) ::</span> (b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> c</a></code></pre></div>
+<div class="sourceCode" id="cb181"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb181-1" title="1"><span class="ot">(.) ::</span> (b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> c</a></code></pre></div>
 <p>And here’s what it does</p>
 <pre><code>(f.g) x ==&gt; f (g x)</code></pre>
 <p>You can use function composition to build functions out of other functions, without mentioning any arguments. For example:</p>
-<div class="sourceCode" id="cb183"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb183-1" data-line-number="1">double x <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x</a>
-<a class="sourceLine" id="cb183-2" data-line-number="2">quadruple <span class="fu">=</span> double <span class="fu">.</span> double  <span class="co">-- computes 2*(2*x) == 4*x</span></a>
-<a class="sourceLine" id="cb183-3" data-line-number="3">f <span class="fu">=</span> quadruple <span class="fu">.</span> (<span class="fu">+</span><span class="dv">1</span>)         <span class="co">-- computes 4*(x+1)</span></a>
-<a class="sourceLine" id="cb183-4" data-line-number="4">g <span class="fu">=</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> quadruple         <span class="co">-- computes 4*x+1</span></a>
-<a class="sourceLine" id="cb183-5" data-line-number="5">third <span class="fu">=</span> head <span class="fu">.</span> tail <span class="fu">.</span> tail   <span class="co">-- fetches the third element of a list</span></a></code></pre></div>
+<div class="sourceCode" id="cb183"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb183-1" title="1">double x <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x</a>
+<a class="sourceLine" id="cb183-2" title="2">quadruple <span class="fu">=</span> double <span class="fu">.</span> double  <span class="co">-- computes 2*(2*x) == 4*x</span></a>
+<a class="sourceLine" id="cb183-3" title="3">f <span class="fu">=</span> quadruple <span class="fu">.</span> (<span class="fu">+</span><span class="dv">1</span>)         <span class="co">-- computes 4*(x+1)</span></a>
+<a class="sourceLine" id="cb183-4" title="4">g <span class="fu">=</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> quadruple         <span class="co">-- computes 4*x+1</span></a>
+<a class="sourceLine" id="cb183-5" title="5">third <span class="fu">=</span> <span class="fu">head</span> <span class="fu">.</span> <span class="fu">tail</span> <span class="fu">.</span> <span class="fu">tail</span>   <span class="co">-- fetches the third element of a list</span></a></code></pre></div>
 <p>We can also reimplement <code>doTwice</code> using <code>(.)</code>. Note how we can use <code>doTwice</code> both as applied only to a function, or as applied to a function and a value.</p>
-<div class="sourceCode" id="cb184"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb184-1" data-line-number="1"><span class="ot">doTwice ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb184-2" data-line-number="2">doTwice f <span class="fu">=</span> f <span class="fu">.</span> f</a></code></pre></div>
-<div class="sourceCode" id="cb185"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb185-1" data-line-number="1"><span class="kw">let</span> ttail <span class="fu">=</span> doTwice tail</a>
-<a class="sourceLine" id="cb185-2" data-line-number="2"><span class="kw">in</span> ttail [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb185-3" data-line-number="3">  <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb185-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb185-5" data-line-number="5">(doTwice tail) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb185-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb185-7" data-line-number="7">doTwice tail [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb184"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb184-1" title="1"><span class="ot">doTwice ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb184-2" title="2">doTwice f <span class="fu">=</span> f <span class="fu">.</span> f</a></code></pre></div>
+<div class="sourceCode" id="cb185"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb185-1" title="1"><span class="kw">let</span> ttail <span class="fu">=</span> doTwice <span class="fu">tail</span></a>
+<a class="sourceLine" id="cb185-2" title="2"><span class="kw">in</span> ttail [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb185-3" title="3">  <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb185-4" title="4"></a>
+<a class="sourceLine" id="cb185-5" title="5">(doTwice <span class="fu">tail</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb185-6" title="6"></a>
+<a class="sourceLine" id="cb185-7" title="7">doTwice <span class="fu">tail</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <p>Often function composition is not used when defining a new function, but instead to avoid defining a helper function. For instance, consider the difference between these two expressions:</p>
-<div class="sourceCode" id="cb186"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb186-1" data-line-number="1"><span class="kw">let</span> notEmpty x <span class="fu">=</span> not (null x)</a>
-<a class="sourceLine" id="cb186-2" data-line-number="2"><span class="kw">in</span> filter notEmpty [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">4</span>]]</a>
-<a class="sourceLine" id="cb186-3" data-line-number="3">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>]]</a></code></pre></div>
-<div class="sourceCode" id="cb187"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb187-1" data-line-number="1">filter (not <span class="fu">.</span> null) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">4</span>]]</a>
-<a class="sourceLine" id="cb187-2" data-line-number="2">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>]]</a></code></pre></div>
+<div class="sourceCode" id="cb186"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb186-1" title="1"><span class="kw">let</span> notEmpty x <span class="fu">=</span> <span class="fu">not</span> (<span class="fu">null</span> x)</a>
+<a class="sourceLine" id="cb186-2" title="2"><span class="kw">in</span> <span class="fu">filter</span> notEmpty [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">4</span>]]</a>
+<a class="sourceLine" id="cb186-3" title="3">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>]]</a></code></pre></div>
+<div class="sourceCode" id="cb187"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb187-1" title="1"><span class="fu">filter</span> (<span class="fu">not</span> <span class="fu">.</span> <span class="fu">null</span>) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">4</span>]]</a>
+<a class="sourceLine" id="cb187-2" title="2">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>]]</a></code></pre></div>
 <p>The other operator, <code>$</code> is more subtle. Let’s look at its type.</p>
-<div class="sourceCode" id="cb188"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb188-1" data-line-number="1"><span class="ot">($) ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb188"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb188-1" title="1"><span class="ot">($) ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> b</a></code></pre></div>
 <p>It takes a function of type <code>a -&gt; b</code> and a value of type <code>a</code>, and returns a value of type <code>b</code>. In other words, it’s a function application operator. The expression <code>f $ x</code> is the same as <code>f x</code>. This seems pretty useless, but it means that the <code>$</code> operator can be used to eliminate parentheses! These expressions are the same:</p>
-<div class="sourceCode" id="cb189"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb189-1" data-line-number="1">head (reverse <span class="st">&quot;abcd&quot;</span>)</a>
-<a class="sourceLine" id="cb189-2" data-line-number="2">head <span class="fu">$</span> reverse <span class="st">&quot;abcd&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb189"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb189-1" title="1"><span class="fu">head</span> (<span class="fu">reverse</span> <span class="st">&quot;abcd&quot;</span>)</a>
+<a class="sourceLine" id="cb189-2" title="2"><span class="fu">head</span> <span class="fu">$</span> <span class="fu">reverse</span> <span class="st">&quot;abcd&quot;</span></a></code></pre></div>
 <p>This isn’t that impressive when it’s used to eliminate one pair of parentheses, but together <code>.</code> and <code>$</code> can eliminate lots of them! For example, we can rewrite</p>
-<div class="sourceCode" id="cb190"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb190-1" data-line-number="1">reverse (map head (map reverse ([<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>])))</a></code></pre></div>
+<div class="sourceCode" id="cb190"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb190-1" title="1"><span class="fu">reverse</span> (<span class="fu">map</span> <span class="fu">head</span> (<span class="fu">map</span> <span class="fu">reverse</span> ([<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>])))</a></code></pre></div>
 <p>as</p>
-<div class="sourceCode" id="cb191"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb191-1" data-line-number="1">(reverse <span class="fu">.</span> map head <span class="fu">.</span> map reverse) ([<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>])</a></code></pre></div>
+<div class="sourceCode" id="cb191"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb191-1" title="1">(<span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">map</span> <span class="fu">head</span> <span class="fu">.</span> <span class="fu">map</span> <span class="fu">reverse</span>) ([<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>])</a></code></pre></div>
 <p>and then</p>
-<div class="sourceCode" id="cb192"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb192-1" data-line-number="1">reverse <span class="fu">.</span> map head <span class="fu">.</span> map reverse <span class="fu">$</span> [<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb192"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb192-1" title="1"><span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">map</span> <span class="fu">head</span> <span class="fu">.</span> <span class="fu">map</span> <span class="fu">reverse</span> <span class="fu">$</span> [<span class="st">&quot;Haskell&quot;</span>,<span class="st">&quot;pro&quot;</span>] <span class="fu">++</span> [<span class="st">&quot;dodo&quot;</span>,<span class="st">&quot;lyric&quot;</span>]</a></code></pre></div>
 <p>Sometimes the operators <code>.</code> and <code>$</code> are useful as functions in their own right. For example, a list of functions can be applied to an argument using map and a section of <code>$</code>:</p>
-<div class="sourceCode" id="cb193"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb193-1" data-line-number="1">map (<span class="fu">$</span><span class="st">&quot;string&quot;</span>) [reverse, take <span class="dv">2</span>, drop <span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb193-2" data-line-number="2">  <span class="fu">==&gt;</span> [reverse <span class="fu">$</span> <span class="st">&quot;string&quot;</span>, take <span class="dv">2</span> <span class="fu">$</span> <span class="st">&quot;string&quot;</span>, drop <span class="dv">2</span> <span class="fu">$</span> <span class="st">&quot;string&quot;</span>]</a>
-<a class="sourceLine" id="cb193-3" data-line-number="3">  <span class="fu">==&gt;</span> [reverse <span class="st">&quot;string&quot;</span>, take <span class="dv">2</span> <span class="st">&quot;string&quot;</span>, drop <span class="dv">2</span> <span class="st">&quot;string&quot;</span>]</a>
-<a class="sourceLine" id="cb193-4" data-line-number="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;gnirts&quot;</span>, <span class="st">&quot;st&quot;</span>, <span class="st">&quot;ring&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb193"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb193-1" title="1"><span class="fu">map</span> (<span class="fu">$</span><span class="st">&quot;string&quot;</span>) [<span class="fu">reverse</span>, <span class="fu">take</span> <span class="dv">2</span>, <span class="fu">drop</span> <span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb193-2" title="2">  <span class="fu">==&gt;</span> [<span class="fu">reverse</span> <span class="fu">$</span> <span class="st">&quot;string&quot;</span>, <span class="fu">take</span> <span class="dv">2</span> <span class="fu">$</span> <span class="st">&quot;string&quot;</span>, <span class="fu">drop</span> <span class="dv">2</span> <span class="fu">$</span> <span class="st">&quot;string&quot;</span>]</a>
+<a class="sourceLine" id="cb193-3" title="3">  <span class="fu">==&gt;</span> [<span class="fu">reverse</span> <span class="st">&quot;string&quot;</span>, <span class="fu">take</span> <span class="dv">2</span> <span class="st">&quot;string&quot;</span>, <span class="fu">drop</span> <span class="dv">2</span> <span class="st">&quot;string&quot;</span>]</a>
+<a class="sourceLine" id="cb193-4" title="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;gnirts&quot;</span>, <span class="st">&quot;st&quot;</span>, <span class="st">&quot;ring&quot;</span>]</a></code></pre></div>
 <!-- `zipWith (.)` would be an example on using `.` as a function. -->
 <p>If this seems complicated, don’t worry. You don’t need to use <code>.</code> and <code>$</code> in your own code until you’re comfortable with them. However, you’ll bump into <code>.</code> and <code>$</code> when reading Haskell examples and code on the internet, so it’s good to know about them. <a href="https://typeclasses.com/featured/dollar">This article</a> might also help.</p>
 <h2 id="example-rewriting-whatfollows"><span class="header-section-number">3.6</span> Example: Rewriting <code>whatFollows</code></h2>
 <p>Now, let’s rewrite the <code>whatFollows</code> example from earlier using the tools we just saw. Here’s the original version:</p>
-<div class="sourceCode" id="cb194"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb194-1" data-line-number="1"><span class="ot">substringsOfLength ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb194-2" data-line-number="2">substringsOfLength n string <span class="fu">=</span> map shorten (tails string)</a>
-<a class="sourceLine" id="cb194-3" data-line-number="3">  <span class="kw">where</span> shorten s <span class="fu">=</span> take n s</a>
-<a class="sourceLine" id="cb194-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb194-5" data-line-number="5"><span class="ot">whatFollows ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb194-6" data-line-number="6">whatFollows c k string <span class="fu">=</span> map tail (filter match (substringsOfLength (k<span class="fu">+</span><span class="dv">1</span>) string))</a>
-<a class="sourceLine" id="cb194-7" data-line-number="7">  <span class="kw">where</span> match sub <span class="fu">=</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb194"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb194-1" title="1"><span class="ot">substringsOfLength ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb194-2" title="2">substringsOfLength n string <span class="fu">=</span> <span class="fu">map</span> shorten (tails string)</a>
+<a class="sourceLine" id="cb194-3" title="3">  <span class="kw">where</span> shorten s <span class="fu">=</span> <span class="fu">take</span> n s</a>
+<a class="sourceLine" id="cb194-4" title="4"></a>
+<a class="sourceLine" id="cb194-5" title="5"><span class="ot">whatFollows ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb194-6" title="6">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> (<span class="fu">filter</span> match (substringsOfLength (k<span class="fu">+</span><span class="dv">1</span>) string))</a>
+<a class="sourceLine" id="cb194-7" title="7">  <span class="kw">where</span> match sub <span class="fu">=</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
 <p>To get started, let’s get rid of the helper function <code>substringsOfLength</code> and move all the code to <code>whatFollows</code>:</p>
-<div class="sourceCode" id="cb195"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb195-1" data-line-number="1">whatFollows c k string <span class="fu">=</span> map tail (filter match (map shorten (tails string)))</a>
-<a class="sourceLine" id="cb195-2" data-line-number="2">  <span class="kw">where</span> shorten s <span class="fu">=</span> take (k<span class="fu">+</span><span class="dv">1</span>) s</a>
-<a class="sourceLine" id="cb195-3" data-line-number="3">        match sub <span class="fu">=</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb195"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb195-1" title="1">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> (<span class="fu">filter</span> match (<span class="fu">map</span> shorten (tails string)))</a>
+<a class="sourceLine" id="cb195-2" title="2">  <span class="kw">where</span> shorten s <span class="fu">=</span> <span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>) s</a>
+<a class="sourceLine" id="cb195-3" title="3">        match sub <span class="fu">=</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
 <p>Now let’s use partial application instead of defining <code>shorten</code>:</p>
-<div class="sourceCode" id="cb196"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb196-1" data-line-number="1">whatFollows c k string <span class="fu">=</span> map tail (filter match (map (take (k<span class="fu">+</span><span class="dv">1</span>)) (tails string)))</a>
-<a class="sourceLine" id="cb196-2" data-line-number="2">  <span class="kw">where</span> match sub <span class="fu">=</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb196"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb196-1" title="1">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> (<span class="fu">filter</span> match (<span class="fu">map</span> (<span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>)) (tails string)))</a>
+<a class="sourceLine" id="cb196-2" title="2">  <span class="kw">where</span> match sub <span class="fu">=</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
 <p>Let’s use <code>.</code> and <code>$</code> to eliminate some of those parentheses:</p>
-<div class="sourceCode" id="cb197"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb197-1" data-line-number="1">whatFollows c k string <span class="fu">=</span> map tail <span class="fu">.</span> filter match <span class="fu">.</span> map (take (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">$</span> tails string</a>
-<a class="sourceLine" id="cb197-2" data-line-number="2">  <span class="kw">where</span> match sub <span class="fu">=</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb197"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb197-1" title="1">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> <span class="fu">.</span> <span class="fu">filter</span> match <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">$</span> tails string</a>
+<a class="sourceLine" id="cb197-2" title="2">  <span class="kw">where</span> match sub <span class="fu">=</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a></code></pre></div>
 <p>We can also replace <code>match</code> with a lambda:</p>
-<div class="sourceCode" id="cb198"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb198-1" data-line-number="1">whatFollows c k string <span class="fu">=</span> map tail <span class="fu">.</span> filter (\sub <span class="ot">-&gt;</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]) <span class="fu">.</span> map (take (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">$</span> tails string</a></code></pre></div>
+<div class="sourceCode" id="cb198"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb198-1" title="1">whatFollows c k string <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> <span class="fu">.</span> <span class="fu">filter</span> (\sub <span class="ot">-&gt;</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]) <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">$</span> tails string</a></code></pre></div>
 <p>Finally, we don’t need to mention the <code>string</code> parameter at all, since we can just express <code>whatFollows</code> as a composition of <code>map</code>, <code>filter</code>, <code>map</code> and <code>tails</code>:</p>
-<div class="sourceCode" id="cb199"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb199-1" data-line-number="1">whatFollows c k <span class="fu">=</span> map tail <span class="fu">.</span> filter (\sub <span class="ot">-&gt;</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]) <span class="fu">.</span> map (take (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">.</span> tails</a></code></pre></div>
+<div class="sourceCode" id="cb199"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb199-1" title="1">whatFollows c k <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> <span class="fu">.</span> <span class="fu">filter</span> (\sub <span class="ot">-&gt;</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]) <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">.</span> tails</a></code></pre></div>
 <p>We can even go a bit further by rewriting the lambda using an operator section</p>
-<div class="sourceCode" id="cb200"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb200-1" data-line-number="1">    \sub <span class="ot">-&gt;</span> take <span class="dv">1</span> sub <span class="fu">==</span> [c]</a>
-<a class="sourceLine" id="cb200-2" data-line-number="2"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> (<span class="fu">==</span>[c]) (take <span class="dv">1</span> sub)</a>
-<a class="sourceLine" id="cb200-3" data-line-number="3"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> (<span class="fu">==</span>[c]) ((take <span class="dv">1</span>) sub)</a>
-<a class="sourceLine" id="cb200-4" data-line-number="4"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> (take <span class="dv">1</span>)) sub</a>
-<a class="sourceLine" id="cb200-5" data-line-number="5"><span class="fu">===</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> (take <span class="dv">1</span>))</a>
-<a class="sourceLine" id="cb200-6" data-line-number="6"><span class="fu">===</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> take <span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb200"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb200-1" title="1">    \sub <span class="ot">-&gt;</span> <span class="fu">take</span> <span class="dv">1</span> sub <span class="fu">==</span> [c]</a>
+<a class="sourceLine" id="cb200-2" title="2"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> (<span class="fu">==</span>[c]) (<span class="fu">take</span> <span class="dv">1</span> sub)</a>
+<a class="sourceLine" id="cb200-3" title="3"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> (<span class="fu">==</span>[c]) ((<span class="fu">take</span> <span class="dv">1</span>) sub)</a>
+<a class="sourceLine" id="cb200-4" title="4"><span class="fu">===</span> \sub <span class="ot">-&gt;</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> (<span class="fu">take</span> <span class="dv">1</span>)) sub</a>
+<a class="sourceLine" id="cb200-5" title="5"><span class="fu">===</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> (<span class="fu">take</span> <span class="dv">1</span>))</a>
+<a class="sourceLine" id="cb200-6" title="6"><span class="fu">===</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> <span class="fu">take</span> <span class="dv">1</span>)</a></code></pre></div>
 <p>Now what we have left is:</p>
-<div class="sourceCode" id="cb201"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb201-1" data-line-number="1">whatFollows c k <span class="fu">=</span> map tail <span class="fu">.</span> filter ((<span class="fu">==</span>[c]) <span class="fu">.</span> take <span class="dv">1</span>) <span class="fu">.</span> map (take (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">.</span> tails</a></code></pre></div>
+<div class="sourceCode" id="cb201"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb201-1" title="1">whatFollows c k <span class="fu">=</span> <span class="fu">map</span> <span class="fu">tail</span> <span class="fu">.</span> <span class="fu">filter</span> ((<span class="fu">==</span>[c]) <span class="fu">.</span> <span class="fu">take</span> <span class="dv">1</span>) <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">take</span> (k<span class="fu">+</span><span class="dv">1</span>)) <span class="fu">.</span> tails</a></code></pre></div>
 <p>This is a somewhat extreme version of the function, but when used in moderation the techniques shown here can make code easier to read.</p>
 <h2 id="more-functional-list-wrangling-examples"><span class="header-section-number">3.7</span> More Functional List Wrangling Examples</h2>
 <p>Here are some more examples of functional programming with lists. Let’s start by introducing a couple of new list functions:</p>
-<div class="sourceCode" id="cb202"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb202-1" data-line-number="1">takeWhile<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- take elements from a list as long as they satisfy a predicate</span></a>
-<a class="sourceLine" id="cb202-2" data-line-number="2">dropWhile<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- drop elements from a list as long as they satisfy a predicate</span></a></code></pre></div>
-<div class="sourceCode" id="cb203"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb203-1" data-line-number="1">takeWhile even [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb203-2" data-line-number="2">dropWhile even [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb202"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb202-1" title="1"><span class="fu">takeWhile</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- take elements from a list as long as they satisfy a predicate</span></a>
+<a class="sourceLine" id="cb202-2" title="2"><span class="fu">dropWhile</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]   <span class="co">-- drop elements from a list as long as they satisfy a predicate</span></a></code></pre></div>
+<div class="sourceCode" id="cb203"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb203-1" title="1"><span class="fu">takeWhile</span> <span class="fu">even</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb203-2" title="2"><span class="fu">dropWhile</span> <span class="fu">even</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>There’s also the function <code>elem</code>, which can be used to check if a list contains an element:</p>
-<div class="sourceCode" id="cb204"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb204-1" data-line-number="1">elem <span class="dv">3</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb204-2" data-line-number="2">elem <span class="dv">4</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb204"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb204-1" title="1"><span class="fu">elem</span> <span class="dv">3</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb204-2" title="2"><span class="fu">elem</span> <span class="dv">4</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]   <span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
 <p>Using these, we can implement a function <code>findSubstring</code> that finds the earliest and longest substring in a string that consist only of the given characters.</p>
-<div class="sourceCode" id="cb205"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb205-1" data-line-number="1"><span class="ot">findSubstring ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb205-2" data-line-number="2">findSubstring chars <span class="fu">=</span> takeWhile (\x <span class="ot">-&gt;</span> elem x chars)</a>
-<a class="sourceLine" id="cb205-3" data-line-number="3">                      <span class="fu">.</span> dropWhile (\x <span class="ot">-&gt;</span> not <span class="fu">$</span> elem x chars)</a></code></pre></div>
-<div class="sourceCode" id="cb206"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb206-1" data-line-number="1">findSubstring <span class="st">&quot;a&quot;</span> <span class="st">&quot;bbaabaaaab&quot;</span>              <span class="fu">==&gt;</span> <span class="st">&quot;aa&quot;</span></a>
-<a class="sourceLine" id="cb206-2" data-line-number="2">findSubstring <span class="st">&quot;abcd&quot;</span> <span class="st">&quot;xxxyyyzabaaxxabcd&quot;</span>    <span class="fu">==&gt;</span> <span class="st">&quot;abaa&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb205"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb205-1" title="1"><span class="ot">findSubstring ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb205-2" title="2">findSubstring chars <span class="fu">=</span> <span class="fu">takeWhile</span> (\x <span class="ot">-&gt;</span> <span class="fu">elem</span> x chars)</a>
+<a class="sourceLine" id="cb205-3" title="3">                      <span class="fu">.</span> <span class="fu">dropWhile</span> (\x <span class="ot">-&gt;</span> <span class="fu">not</span> <span class="fu">$</span> <span class="fu">elem</span> x chars)</a></code></pre></div>
+<div class="sourceCode" id="cb206"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb206-1" title="1">findSubstring <span class="st">&quot;a&quot;</span> <span class="st">&quot;bbaabaaaab&quot;</span>              <span class="fu">==&gt;</span> <span class="st">&quot;aa&quot;</span></a>
+<a class="sourceLine" id="cb206-2" title="2">findSubstring <span class="st">&quot;abcd&quot;</span> <span class="st">&quot;xxxyyyzabaaxxabcd&quot;</span>    <span class="fu">==&gt;</span> <span class="st">&quot;abaa&quot;</span></a></code></pre></div>
 <!-- `zipWith` has already been introduced in section 3.3 above. -->
 <p>The function <code>zipWith</code> lets you combine two lists element-by-element:</p>
-<div class="sourceCode" id="cb207"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb207-1" data-line-number="1">zipWith<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a></code></pre></div>
-<div class="sourceCode" id="cb208"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb208-1" data-line-number="1">zipWith (<span class="fu">++</span>) [<span class="st">&quot;John&quot;</span>,<span class="st">&quot;Mary&quot;</span>] [<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;Cooper&quot;</span>]</a>
-<a class="sourceLine" id="cb208-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;JohnSmith&quot;</span>,<span class="st">&quot;MaryCooper&quot;</span>]</a>
-<a class="sourceLine" id="cb208-3" data-line-number="3">zipWith take [<span class="dv">4</span>,<span class="dv">3</span>] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;Warden&quot;</span>]</a>
-<a class="sourceLine" id="cb208-4" data-line-number="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;Hell&quot;</span>,<span class="st">&quot;War&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb207"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb207-1" title="1"><span class="fu">zipWith</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [c]</a></code></pre></div>
+<div class="sourceCode" id="cb208"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb208-1" title="1"><span class="fu">zipWith</span> (<span class="fu">++</span>) [<span class="st">&quot;John&quot;</span>,<span class="st">&quot;Mary&quot;</span>] [<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;Cooper&quot;</span>]</a>
+<a class="sourceLine" id="cb208-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;JohnSmith&quot;</span>,<span class="st">&quot;MaryCooper&quot;</span>]</a>
+<a class="sourceLine" id="cb208-3" title="3"><span class="fu">zipWith</span> <span class="fu">take</span> [<span class="dv">4</span>,<span class="dv">3</span>] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;Warden&quot;</span>]</a>
+<a class="sourceLine" id="cb208-4" title="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;Hell&quot;</span>,<span class="st">&quot;War&quot;</span>]</a></code></pre></div>
 <p>Sometimes with higher-order functions it’s useful to have a function that does nothing. The function <code>id :: a -&gt; a</code> is the identity function and just returns its argument.</p>
-<div class="sourceCode" id="cb209"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb209-1" data-line-number="1">id <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb209-2" data-line-number="2">map id [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb209"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb209-1" title="1"><span class="fu">id</span> <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb209-2" title="2"><span class="fu">map</span> <span class="fu">id</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>This seems a bit useless, but you can use it for example with <code>filter</code> or <code>dropWhile</code>:</p>
-<div class="sourceCode" id="cb210"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb210-1" data-line-number="1">filter id [<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">True</span>]  <span class="fu">==&gt;</span>  [<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">True</span>]</a>
-<a class="sourceLine" id="cb210-2" data-line-number="2">dropWhile id [<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]  <span class="fu">==&gt;</span>  [<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb210"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb210-1" title="1"><span class="fu">filter</span> <span class="fu">id</span> [<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">True</span>]  <span class="fu">==&gt;</span>  [<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">True</span>]</a>
+<a class="sourceLine" id="cb210-2" title="2"><span class="fu">dropWhile</span> <span class="fu">id</span> [<span class="dt">True</span>,<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]  <span class="fu">==&gt;</span>  [<span class="dt">False</span>,<span class="dt">True</span>,<span class="dt">False</span>]</a></code></pre></div>
 <p>Another very simple but sometimes crucial function is the constant function, <code>const :: a -&gt; b -&gt; a</code>. It always returns its first argument:</p>
-<div class="sourceCode" id="cb211"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb211-1" data-line-number="1">const <span class="dv">3</span> <span class="dt">True</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb211-2" data-line-number="2">const <span class="dv">3</span> <span class="dv">0</span>    <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb211"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb211-1" title="1"><span class="fu">const</span> <span class="dv">3</span> <span class="dt">True</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb211-2" title="2"><span class="fu">const</span> <span class="dv">3</span> <span class="dv">0</span>    <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>When partially applied it can be used when you need a function that always returns the same value:</p>
-<div class="sourceCode" id="cb212"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb212-1" data-line-number="1">map (const <span class="dv">5</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">5</span>,<span class="dv">5</span>,<span class="dv">5</span>,<span class="dv">5</span>]</a>
-<a class="sourceLine" id="cb212-2" data-line-number="2">filter (const <span class="dt">True</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb212"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb212-1" title="1"><span class="fu">map</span> (<span class="fu">const</span> <span class="dv">5</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">5</span>,<span class="dv">5</span>,<span class="dv">5</span>,<span class="dv">5</span>]</a>
+<a class="sourceLine" id="cb212-2" title="2"><span class="fu">filter</span> (<span class="fu">const</span> <span class="dt">True</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <h2 id="lists-and-recursion"><span class="header-section-number">3.8</span> Lists and Recursion</h2>
 <p>Here’s a new operator, <code>:</code></p>
-<div class="sourceCode" id="cb213"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb213-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">:</span>[]</a>
-<a class="sourceLine" id="cb213-2" data-line-number="2">[<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb213-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb213-4" data-line-number="4">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb213-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> tail (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb213-6" data-line-number="6">[<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb213-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> head (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb213-8" data-line-number="8"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb213-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t (<span class="fu">:</span>)</a>
-<a class="sourceLine" id="cb213-10" data-line-number="10"><span class="ot">(:) ::</span> a <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb213"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb213-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">:</span>[]</a>
+<a class="sourceLine" id="cb213-2" title="2">[<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb213-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb213-4" title="4">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb213-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">tail</span> (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb213-6" title="6">[<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb213-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb213-8" title="8"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb213-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t (<span class="fu">:</span>)</a>
+<a class="sourceLine" id="cb213-10" title="10"><span class="ot">(:) ::</span> a <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>The <code>:</code> operator builds a list out of a head and a tail. In other words, <code>x : xs</code> is the same as <code>[x] ++ xs</code>. Why do we need an operator for this?</p>
 <p>Actually, <code>:</code> is the <em>constructor</em> for lists: it returns a new linked list node. The other list constructor is <code>[]</code>, the empty list. All lists are built using <code>:</code> and <code>[]</code>. The familiar <code>[x,y,z]</code> syntax is actually just a nicer way to write <code>x:y:z:[]</code>, or even more explicitly, <code>x:(y:(z:[]))</code>. In fact <code>(++)</code> is defined in terms of <code>:</code> and recursion in the standard library.</p>
 <p>Here’s a picture of how <code>[1,2,3]</code> is structured in memory:</p>
@@ -1943,155 +1941,155 @@ Prelude&gt; map (add 3) [1,2,3]
 -->
 <h3 id="building-a-list"><span class="header-section-number">3.8.1</span> Building a List</h3>
 <p>Using <code>:</code> we can define recursive functions that build lists. For example here’s a function that builds lists like <code>[3,2,1]</code>:</p>
-<div class="sourceCode" id="cb214"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb214-1" data-line-number="1">descend <span class="dv">0</span> <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb214-2" data-line-number="2">descend n <span class="fu">=</span> n <span class="fu">:</span> descend (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb215"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb215-1" data-line-number="1">descend <span class="dv">4</span> <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb214"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb214-1" title="1">descend <span class="dv">0</span> <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb214-2" title="2">descend n <span class="fu">=</span> n <span class="fu">:</span> descend (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb215"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb215-1" title="1">descend <span class="dv">4</span> <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
 <p>Here’s a function that builds a list by iterating a function <code>n</code> times:</p>
-<div class="sourceCode" id="cb216"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb216-1" data-line-number="1">iterate f <span class="dv">0</span> x <span class="fu">=</span> [x]</a>
-<a class="sourceLine" id="cb216-2" data-line-number="2">iterate f n x <span class="fu">=</span> x <span class="fu">:</span> iterate f (n<span class="fu">-</span><span class="dv">1</span>) (f x)</a></code></pre></div>
-<div class="sourceCode" id="cb217"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb217-1" data-line-number="1">iterate (<span class="fu">*</span><span class="dv">2</span>) <span class="dv">4</span> <span class="dv">3</span> <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">6</span>,<span class="dv">12</span>,<span class="dv">24</span>,<span class="dv">48</span>]</a>
-<a class="sourceLine" id="cb217-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb217-3" data-line-number="3"><span class="kw">let</span> xs <span class="fu">=</span> <span class="st">&quot;terve&quot;</span></a>
-<a class="sourceLine" id="cb217-4" data-line-number="4"><span class="kw">in</span> iterate tail (length xs) xs</a>
-<a class="sourceLine" id="cb217-5" data-line-number="5">  <span class="fu">==&gt;</span> [<span class="st">&quot;terve&quot;</span>,<span class="st">&quot;erve&quot;</span>,<span class="st">&quot;rve&quot;</span>,<span class="st">&quot;ve&quot;</span>,<span class="st">&quot;e&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb216"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb216-1" title="1"><span class="fu">iterate</span> f <span class="dv">0</span> x <span class="fu">=</span> [x]</a>
+<a class="sourceLine" id="cb216-2" title="2"><span class="fu">iterate</span> f n x <span class="fu">=</span> x <span class="fu">:</span> <span class="fu">iterate</span> f (n<span class="fu">-</span><span class="dv">1</span>) (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb217"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb217-1" title="1"><span class="fu">iterate</span> (<span class="fu">*</span><span class="dv">2</span>) <span class="dv">4</span> <span class="dv">3</span> <span class="fu">==&gt;</span> [<span class="dv">3</span>,<span class="dv">6</span>,<span class="dv">12</span>,<span class="dv">24</span>,<span class="dv">48</span>]</a>
+<a class="sourceLine" id="cb217-2" title="2"></a>
+<a class="sourceLine" id="cb217-3" title="3"><span class="kw">let</span> xs <span class="fu">=</span> <span class="st">&quot;terve&quot;</span></a>
+<a class="sourceLine" id="cb217-4" title="4"><span class="kw">in</span> <span class="fu">iterate</span> <span class="fu">tail</span> (<span class="fu">length</span> xs) xs</a>
+<a class="sourceLine" id="cb217-5" title="5">  <span class="fu">==&gt;</span> [<span class="st">&quot;terve&quot;</span>,<span class="st">&quot;erve&quot;</span>,<span class="st">&quot;rve&quot;</span>,<span class="st">&quot;ve&quot;</span>,<span class="st">&quot;e&quot;</span>,<span class="st">&quot;&quot;</span>]</a></code></pre></div>
 <p>Here’s a more complicated example: splitting a string into pieces at a given character:</p>
-<div class="sourceCode" id="cb218"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb218-1" data-line-number="1"><span class="ot">split ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb218-2" data-line-number="2">split c [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb218-3" data-line-number="3">split c xs <span class="fu">=</span> start <span class="fu">:</span> split c (drop <span class="dv">1</span> rest)</a>
-<a class="sourceLine" id="cb218-4" data-line-number="4">  <span class="kw">where</span> start <span class="fu">=</span> takeWhile (<span class="fu">/=</span>c) xs</a>
-<a class="sourceLine" id="cb218-5" data-line-number="5">        rest <span class="fu">=</span> dropWhile (<span class="fu">/=</span>c) xs</a></code></pre></div>
-<div class="sourceCode" id="cb219"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb219-1" data-line-number="1">split <span class="ch">&#39;x&#39;</span> <span class="st">&quot;fooxxbarxquux&quot;</span>   <span class="fu">==&gt;</span>   [<span class="st">&quot;foo&quot;</span>,<span class="st">&quot;&quot;</span>,<span class="st">&quot;bar&quot;</span>,<span class="st">&quot;quu&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb218"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb218-1" title="1"><span class="ot">split ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb218-2" title="2">split c [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb218-3" title="3">split c xs <span class="fu">=</span> start <span class="fu">:</span> split c (<span class="fu">drop</span> <span class="dv">1</span> rest)</a>
+<a class="sourceLine" id="cb218-4" title="4">  <span class="kw">where</span> start <span class="fu">=</span> <span class="fu">takeWhile</span> (<span class="fu">/=</span>c) xs</a>
+<a class="sourceLine" id="cb218-5" title="5">        rest <span class="fu">=</span> <span class="fu">dropWhile</span> (<span class="fu">/=</span>c) xs</a></code></pre></div>
+<div class="sourceCode" id="cb219"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb219-1" title="1">split <span class="ch">&#39;x&#39;</span> <span class="st">&quot;fooxxbarxquux&quot;</span>   <span class="fu">==&gt;</span>   [<span class="st">&quot;foo&quot;</span>,<span class="st">&quot;&quot;</span>,<span class="st">&quot;bar&quot;</span>,<span class="st">&quot;quu&quot;</span>]</a></code></pre></div>
 <h3 id="pattern-matching-for-lists"><span class="header-section-number">3.8.2</span> Pattern Matching for Lists</h3>
 <p>Last lecture, it was said that constructors are things that can be pattern matched on. Above, it was divulged that the constructors for the list type are <code>:</code> and <code>[]</code>. We can put one and one together and guess that we can pattern match on <code>:</code> and <code>[]</code>. This is true! Here’s how you can define your own versions of <code>head</code> and <code>tail</code> using pattern matching:</p>
-<div class="sourceCode" id="cb220"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb220-1" data-line-number="1"><span class="ot">myhead ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb220-2" data-line-number="2">myhead [] <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb220-3" data-line-number="3">myhead (first<span class="fu">:</span>rest) <span class="fu">=</span> first</a>
-<a class="sourceLine" id="cb220-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb220-5" data-line-number="5"><span class="ot">mytail ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb220-6" data-line-number="6">mytail [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb220-7" data-line-number="7">mytail (first<span class="fu">:</span>rest) <span class="fu">=</span> rest</a></code></pre></div>
+<div class="sourceCode" id="cb220"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb220-1" title="1"><span class="ot">myhead ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb220-2" title="2">myhead [] <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb220-3" title="3">myhead (first<span class="fu">:</span>rest) <span class="fu">=</span> first</a>
+<a class="sourceLine" id="cb220-4" title="4"></a>
+<a class="sourceLine" id="cb220-5" title="5"><span class="ot">mytail ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb220-6" title="6">mytail [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb220-7" title="7">mytail (first<span class="fu">:</span>rest) <span class="fu">=</span> rest</a></code></pre></div>
 <p>You can <em>nest</em> patterns. That is, you can pattern match more than one element from the start of a list. In this example, we use the pattern <code>(a:b:_)</code> which is the same as <code>(a:(b:_))</code>:</p>
-<div class="sourceCode" id="cb221"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb221-1" data-line-number="1"><span class="ot">sumFirstTwo ::</span> [<span class="dt">Integer</span>] <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
-<a class="sourceLine" id="cb221-2" data-line-number="2"><span class="co">-- this equation gets used for lists of length at least two</span></a>
-<a class="sourceLine" id="cb221-3" data-line-number="3">sumFirstTwo (a<span class="fu">:</span>b<span class="fu">:</span>_) <span class="fu">=</span> a<span class="fu">+</span>b</a>
-<a class="sourceLine" id="cb221-4" data-line-number="4"><span class="co">-- this equation gets used for all other lists (i.e. lists of length 0 or 1)</span></a>
-<a class="sourceLine" id="cb221-5" data-line-number="5">sumFirstTwo _       <span class="fu">=</span> <span class="dv">0</span></a></code></pre></div>
-<div class="sourceCode" id="cb222"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb222-1" data-line-number="1">sumFirstTwo [<span class="dv">1</span>]      <span class="fu">==&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb222-2" data-line-number="2">sumFirstTwo [<span class="dv">1</span>,<span class="dv">2</span>]    <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb222-3" data-line-number="3">sumFirstTwo [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>]  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb221"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb221-1" title="1"><span class="ot">sumFirstTwo ::</span> [<span class="dt">Integer</span>] <span class="ot">-&gt;</span> <span class="dt">Integer</span></a>
+<a class="sourceLine" id="cb221-2" title="2"><span class="co">-- this equation gets used for lists of length at least two</span></a>
+<a class="sourceLine" id="cb221-3" title="3">sumFirstTwo (a<span class="fu">:</span>b<span class="fu">:</span>_) <span class="fu">=</span> a<span class="fu">+</span>b</a>
+<a class="sourceLine" id="cb221-4" title="4"><span class="co">-- this equation gets used for all other lists (i.e. lists of length 0 or 1)</span></a>
+<a class="sourceLine" id="cb221-5" title="5">sumFirstTwo _       <span class="fu">=</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb222"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb222-1" title="1">sumFirstTwo [<span class="dv">1</span>]      <span class="fu">==&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb222-2" title="2">sumFirstTwo [<span class="dv">1</span>,<span class="dv">2</span>]    <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb222-3" title="3">sumFirstTwo [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>]  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>Here’s an example that uses many different list patterns:</p>
-<div class="sourceCode" id="cb223"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb223-1" data-line-number="1"><span class="ot">describeList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb223-2" data-line-number="2">describeList []         <span class="fu">=</span> <span class="st">&quot;an empty list&quot;</span></a>
-<a class="sourceLine" id="cb223-3" data-line-number="3">describeList (x<span class="fu">:</span>[])     <span class="fu">=</span> <span class="st">&quot;a list with one element&quot;</span></a>
-<a class="sourceLine" id="cb223-4" data-line-number="4">describeList (x<span class="fu">:</span>y<span class="fu">:</span>[])   <span class="fu">=</span> <span class="st">&quot;a list with two elements&quot;</span></a>
-<a class="sourceLine" id="cb223-5" data-line-number="5">describeList (x<span class="fu">:</span>y<span class="fu">:</span>z<span class="fu">:</span>xs) <span class="fu">=</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb224"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb224-1" data-line-number="1">describeList [<span class="dv">1</span>,<span class="dv">3</span>]        <span class="fu">==&gt;</span> <span class="st">&quot;a list with two elements&quot;</span></a>
-<a class="sourceLine" id="cb224-2" data-line-number="2">describeList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]  <span class="fu">==&gt;</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb223"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb223-1" title="1"><span class="ot">describeList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb223-2" title="2">describeList []         <span class="fu">=</span> <span class="st">&quot;an empty list&quot;</span></a>
+<a class="sourceLine" id="cb223-3" title="3">describeList (x<span class="fu">:</span>[])     <span class="fu">=</span> <span class="st">&quot;a list with one element&quot;</span></a>
+<a class="sourceLine" id="cb223-4" title="4">describeList (x<span class="fu">:</span>y<span class="fu">:</span>[])   <span class="fu">=</span> <span class="st">&quot;a list with two elements&quot;</span></a>
+<a class="sourceLine" id="cb223-5" title="5">describeList (x<span class="fu">:</span>y<span class="fu">:</span>z<span class="fu">:</span>xs) <span class="fu">=</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb224"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb224-1" title="1">describeList [<span class="dv">1</span>,<span class="dv">3</span>]        <span class="fu">==&gt;</span> <span class="st">&quot;a list with two elements&quot;</span></a>
+<a class="sourceLine" id="cb224-2" title="2">describeList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]  <span class="fu">==&gt;</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
 <p>List patterns that end with <code>:[]</code> can be typed out as list literals. That is, just like <code>[1,2,3]</code> is the same value as <code>1:2:3:[]</code>, the pattern <code>[x,y]</code> is the same as the pattern <code>x:y:[]</code>. Let’s rewrite that previous example.</p>
-<div class="sourceCode" id="cb225"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb225-1" data-line-number="1"><span class="ot">describeList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb225-2" data-line-number="2">describeList []         <span class="fu">=</span> <span class="st">&quot;an empty list&quot;</span></a>
-<a class="sourceLine" id="cb225-3" data-line-number="3">describeList [x]        <span class="fu">=</span> <span class="st">&quot;a list with exactly one element&quot;</span></a>
-<a class="sourceLine" id="cb225-4" data-line-number="4">describeList [x,y]      <span class="fu">=</span> <span class="st">&quot;a list with exactly two elements&quot;</span></a>
-<a class="sourceLine" id="cb225-5" data-line-number="5">describeList (x<span class="fu">:</span>y<span class="fu">:</span>z<span class="fu">:</span>xs) <span class="fu">=</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb225"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb225-1" title="1"><span class="ot">describeList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb225-2" title="2">describeList []         <span class="fu">=</span> <span class="st">&quot;an empty list&quot;</span></a>
+<a class="sourceLine" id="cb225-3" title="3">describeList [x]        <span class="fu">=</span> <span class="st">&quot;a list with exactly one element&quot;</span></a>
+<a class="sourceLine" id="cb225-4" title="4">describeList [x,y]      <span class="fu">=</span> <span class="st">&quot;a list with exactly two elements&quot;</span></a>
+<a class="sourceLine" id="cb225-5" title="5">describeList (x<span class="fu">:</span>y<span class="fu">:</span>z<span class="fu">:</span>xs) <span class="fu">=</span> <span class="st">&quot;a list with at least three elements&quot;</span></a></code></pre></div>
 <p>Another way we can nest patterns is pattern matching on the head while pattern matching on a list. For example this function checks if a list starts with <code>0</code>:</p>
-<div class="sourceCode" id="cb226"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb226-1" data-line-number="1"><span class="ot">startsWithZero ::</span> [<span class="dt">Integer</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb226-2" data-line-number="2">startsWithZero (<span class="dv">0</span><span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb226-3" data-line-number="3">startsWithZero (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb226-4" data-line-number="4">startsWithZero []     <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb226"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb226-1" title="1"><span class="ot">startsWithZero ::</span> [<span class="dt">Integer</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb226-2" title="2">startsWithZero (<span class="dv">0</span><span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb226-3" title="3">startsWithZero (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb226-4" title="4">startsWithZero []     <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <!-- The last two cases could be merged as `startsWithZero _ = False`. -->
 <h3 id="consuming-a-list"><span class="header-section-number">3.8.3</span> Consuming a List</h3>
 <p>Using pattern matching and recursion, we can recursively process a whole list. Here’s how you sum all the numbers in a list:</p>
-<div class="sourceCode" id="cb227"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb227-1" data-line-number="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb227-2" data-line-number="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb227-3" data-line-number="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a></code></pre></div>
+<div class="sourceCode" id="cb227"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb227-1" title="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb227-2" title="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb227-3" title="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a></code></pre></div>
 <p>Here’s how you compute the largest number in a list, this time using a helper function.</p>
-<div class="sourceCode" id="cb228"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb228-1" data-line-number="1"><span class="ot">myMaximum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb228-2" data-line-number="2">myMaximum [] <span class="fu">=</span> <span class="dv">0</span>       <span class="co">-- actually this should be some sort of error...</span></a>
-<a class="sourceLine" id="cb228-3" data-line-number="3">myMaximum (x<span class="fu">:</span>xs) <span class="fu">=</span> go x xs</a>
-<a class="sourceLine" id="cb228-4" data-line-number="4">  <span class="kw">where</span> go biggest [] <span class="fu">=</span> biggest</a>
-<a class="sourceLine" id="cb228-5" data-line-number="5">        go biggest (x<span class="fu">:</span>xs) <span class="fu">=</span> go (max biggest x) xs</a></code></pre></div>
+<div class="sourceCode" id="cb228"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb228-1" title="1"><span class="ot">myMaximum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb228-2" title="2">myMaximum [] <span class="fu">=</span> <span class="dv">0</span>       <span class="co">-- actually this should be some sort of error...</span></a>
+<a class="sourceLine" id="cb228-3" title="3">myMaximum (x<span class="fu">:</span>xs) <span class="fu">=</span> go x xs</a>
+<a class="sourceLine" id="cb228-4" title="4">  <span class="kw">where</span> go biggest [] <span class="fu">=</span> biggest</a>
+<a class="sourceLine" id="cb228-5" title="5">        go biggest (x<span class="fu">:</span>xs) <span class="fu">=</span> go (<span class="fu">max</span> biggest x) xs</a></code></pre></div>
 <p><strong>Note!</strong>, “<code>go</code>” is just a cute name for the helper function here. It’s not special syntax.</p>
 <p>It’s often convenient to use nested patterns while consuming a list. Here’s an example that counts how many <code>Nothing</code> values occur in a list of <code>Maybe</code>s:</p>
-<div class="sourceCode" id="cb229"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb229-1" data-line-number="1"><span class="ot">countNothings ::</span> [<span class="dt">Maybe</span> a] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb229-2" data-line-number="2">countNothings [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb229-3" data-line-number="3">countNothings (<span class="dt">Nothing</span> <span class="fu">:</span> xs) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> countNothings xs</a>
-<a class="sourceLine" id="cb229-4" data-line-number="4">countNothings (<span class="dt">Just</span> _  <span class="fu">:</span> xs) <span class="fu">=</span> countNothings xs</a></code></pre></div>
-<div class="sourceCode" id="cb230"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb230-1" data-line-number="1">countNothings [<span class="dt">Nothing</span>,<span class="dt">Just</span> <span class="dv">1</span>,<span class="dt">Nothing</span>]  <span class="fu">==&gt;</span>  <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb229"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb229-1" title="1"><span class="ot">countNothings ::</span> [<span class="dt">Maybe</span> a] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb229-2" title="2">countNothings [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb229-3" title="3">countNothings (<span class="dt">Nothing</span> <span class="fu">:</span> xs) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> countNothings xs</a>
+<a class="sourceLine" id="cb229-4" title="4">countNothings (<span class="dt">Just</span> _  <span class="fu">:</span> xs) <span class="fu">=</span> countNothings xs</a></code></pre></div>
+<div class="sourceCode" id="cb230"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb230-1" title="1">countNothings [<span class="dt">Nothing</span>,<span class="dt">Just</span> <span class="dv">1</span>,<span class="dt">Nothing</span>]  <span class="fu">==&gt;</span>  <span class="dv">2</span></a></code></pre></div>
 <h3 id="building-and-consuming-a-list"><span class="header-section-number">3.8.4</span> Building and Consuming a List</h3>
 <p>Now that we can build and consume lists, let’s do both of them at the same time. This function doubles all elements in a list.</p>
-<div class="sourceCode" id="cb231"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb231-1" data-line-number="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb231-2" data-line-number="2">doubleList [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb231-3" data-line-number="3">doubleList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x <span class="fu">:</span> doubleList xs</a></code></pre></div>
+<div class="sourceCode" id="cb231"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb231-1" title="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb231-2" title="2">doubleList [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb231-3" title="3">doubleList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x <span class="fu">:</span> doubleList xs</a></code></pre></div>
 <p>It evaluates like this:</p>
-<div class="sourceCode" id="cb232"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb232-1" data-line-number="1">doubleList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb232-2" data-line-number="2"><span class="fu">===</span> doubleList (<span class="dv">1</span><span class="fu">:</span>(<span class="dv">2</span><span class="fu">:</span>(<span class="dv">3</span><span class="fu">:</span>[])))</a>
-<a class="sourceLine" id="cb232-3" data-line-number="3"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> doubleList (<span class="dv">2</span><span class="fu">:</span>(<span class="dv">3</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb232-4" data-line-number="4"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> doubleList (<span class="dv">3</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb232-5" data-line-number="5"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">3</span> <span class="fu">:</span> doubleList []))</a>
-<a class="sourceLine" id="cb232-6" data-line-number="6"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">3</span> <span class="fu">:</span> []))</a>
-<a class="sourceLine" id="cb232-7" data-line-number="7"><span class="fu">===</span> [<span class="dv">2</span><span class="fu">*</span><span class="dv">1</span>, <span class="dv">2</span><span class="fu">*</span><span class="dv">2</span>, <span class="dv">2</span><span class="fu">*</span><span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb232-8" data-line-number="8"><span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb232"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb232-1" title="1">doubleList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb232-2" title="2"><span class="fu">===</span> doubleList (<span class="dv">1</span><span class="fu">:</span>(<span class="dv">2</span><span class="fu">:</span>(<span class="dv">3</span><span class="fu">:</span>[])))</a>
+<a class="sourceLine" id="cb232-3" title="3"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> doubleList (<span class="dv">2</span><span class="fu">:</span>(<span class="dv">3</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb232-4" title="4"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> doubleList (<span class="dv">3</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb232-5" title="5"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">3</span> <span class="fu">:</span> doubleList []))</a>
+<a class="sourceLine" id="cb232-6" title="6"><span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">*</span><span class="dv">1</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">2</span> <span class="fu">:</span> (<span class="dv">2</span><span class="fu">*</span><span class="dv">3</span> <span class="fu">:</span> []))</a>
+<a class="sourceLine" id="cb232-7" title="7"><span class="fu">===</span> [<span class="dv">2</span><span class="fu">*</span><span class="dv">1</span>, <span class="dv">2</span><span class="fu">*</span><span class="dv">2</span>, <span class="dv">2</span><span class="fu">*</span><span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb232-8" title="8"><span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
 <p>Once you know pattern matching for lists, it’s straightforward to define <code>map</code> and <code>filter</code>. Actually, let’s just look at the GHC standard library implementations. <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/src/GHC.Base.html#map">Here’s map</a>:</p>
-<div class="sourceCode" id="cb233"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb233-1" data-line-number="1">map<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb233-2" data-line-number="2">map _ []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb233-3" data-line-number="3">map f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> map f xs</a></code></pre></div>
+<div class="sourceCode" id="cb233"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb233-1" title="1"><span class="fu">map</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb233-2" title="2"><span class="fu">map</span> _ []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb233-3" title="3"><span class="fu">map</span> f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> <span class="fu">map</span> f xs</a></code></pre></div>
 <p>and <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/src/GHC.List.html#filter">here’s filter</a>:</p>
-<div class="sourceCode" id="cb234"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb234-1" data-line-number="1">filter<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb234-2" data-line-number="2">filter _pred []    <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb234-3" data-line-number="3">filter pred (x<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb234-4" data-line-number="4">  <span class="fu">|</span> pred x         <span class="fu">=</span> x <span class="fu">:</span> filter pred xs</a>
-<a class="sourceLine" id="cb234-5" data-line-number="5">  <span class="fu">|</span> otherwise      <span class="fu">=</span> filter pred xs</a></code></pre></div>
+<div class="sourceCode" id="cb234"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb234-1" title="1"><span class="fu">filter</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb234-2" title="2"><span class="fu">filter</span> _pred []    <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb234-3" title="3"><span class="fu">filter</span> <span class="fu">pred</span> (x<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb234-4" title="4">  <span class="fu">|</span> <span class="fu">pred</span> x         <span class="fu">=</span> x <span class="fu">:</span> <span class="fu">filter</span> <span class="fu">pred</span> xs</a>
+<a class="sourceLine" id="cb234-5" title="5">  <span class="fu">|</span> <span class="fu">otherwise</span>      <span class="fu">=</span> <span class="fu">filter</span> <span class="fu">pred</span> xs</a></code></pre></div>
 <p>(<strong>Note!</strong> Naming the argument <code>_pred</code> is a way to tell the reader of the code that this argument is unused. It could have been just <code>_</code> as well.)</p>
 <h3 id="tail-recursion-and-lists"><span class="header-section-number">3.8.5</span> Tail Recursion and Lists</h3>
 <p>When a recursive function evaluates to a new call to that same function with different arguments, it is called <em>tail-recursive</em>. (The recursive call is said to be in <em>tail position</em>.) This is the type of recursion that corresponds to an imperative loop. We’ve already seen many examples of tail-recursive functions, but we haven’t really contrasted the two ways for writing the same function. This is <code>sumNumbers</code> from earlier in this lecture:</p>
-<div class="sourceCode" id="cb235"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb235-1" data-line-number="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb235-2" data-line-number="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb235-3" data-line-number="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a></code></pre></div>
+<div class="sourceCode" id="cb235"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb235-1" title="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb235-2" title="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb235-3" title="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a></code></pre></div>
 <p>In the second equation the function <code>+</code> is at the top level, i.e. in tail position. The recursive call to <code>sumNumbers</code> is an argument of <code>+</code>. This is <code>sumNumbers</code> written using a tail recursive helper function:</p>
-<div class="sourceCode" id="cb236"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb236-1" data-line-number="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb236-2" data-line-number="2">sumNumbers xs <span class="fu">=</span> go <span class="dv">0</span> xs</a>
-<a class="sourceLine" id="cb236-3" data-line-number="3">  <span class="kw">where</span> go sum [] <span class="fu">=</span> sum</a>
-<a class="sourceLine" id="cb236-4" data-line-number="4">        go sum (x<span class="fu">:</span>xs) <span class="fu">=</span> go (sum<span class="fu">+</span>x) xs</a></code></pre></div>
+<div class="sourceCode" id="cb236"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb236-1" title="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb236-2" title="2">sumNumbers xs <span class="fu">=</span> go <span class="dv">0</span> xs</a>
+<a class="sourceLine" id="cb236-3" title="3">  <span class="kw">where</span> go <span class="fu">sum</span> [] <span class="fu">=</span> <span class="fu">sum</span></a>
+<a class="sourceLine" id="cb236-4" title="4">        go <span class="fu">sum</span> (x<span class="fu">:</span>xs) <span class="fu">=</span> go (<span class="fu">sum+</span>x) xs</a></code></pre></div>
 <p>Note the second equation of <code>go</code>: it has the recursive call to <code>go</code> at the top level, i.e. in tail position. The <code>+</code> is now in an argument to <code>go</code>.</p>
 <p>For a function like <code>sumNumbers</code> that produces a single value (a number), it doesn’t really matter which form of recursion you choose. The non-tail-recursive function is easier to read, while the tail-recursive one can be easier to come up with. You can try writing a function both ways. The tail-recursive form might be more efficient, but that depends on many details. We’ll talk more about Haskell performance in part 2 of this course.</p>
 <p>However, when you’re returning a list there is a big difference between these two forms. Consider the function <code>doubleList</code> from earlier. Here it is again, implemented first directly, and then via a tail-recursive helper function.</p>
-<div class="sourceCode" id="cb237"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb237-1" data-line-number="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb237-2" data-line-number="2">doubleList [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb237-3" data-line-number="3">doubleList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x <span class="fu">:</span> doubleList xs</a></code></pre></div>
-<div class="sourceCode" id="cb238"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb238-1" data-line-number="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb238-2" data-line-number="2">doubleList xs <span class="fu">=</span> go [] xs</a>
-<a class="sourceLine" id="cb238-3" data-line-number="3">    <span class="kw">where</span> go result [] <span class="fu">=</span> result</a>
-<a class="sourceLine" id="cb238-4" data-line-number="4">          go result (x<span class="fu">:</span>xs) <span class="fu">=</span> go (result<span class="fu">++</span>[<span class="dv">2</span><span class="fu">*</span>x]) xs</a></code></pre></div>
+<div class="sourceCode" id="cb237"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb237-1" title="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb237-2" title="2">doubleList [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb237-3" title="3">doubleList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">2</span><span class="fu">*</span>x <span class="fu">:</span> doubleList xs</a></code></pre></div>
+<div class="sourceCode" id="cb238"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb238-1" title="1"><span class="ot">doubleList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb238-2" title="2">doubleList xs <span class="fu">=</span> go [] xs</a>
+<a class="sourceLine" id="cb238-3" title="3">    <span class="kw">where</span> go result [] <span class="fu">=</span> result</a>
+<a class="sourceLine" id="cb238-4" title="4">          go result (x<span class="fu">:</span>xs) <span class="fu">=</span> go (result<span class="fu">++</span>[<span class="dv">2</span><span class="fu">*</span>x]) xs</a></code></pre></div>
 <p>Here the direct version is much more efficient. The <code>(:)</code> operator works in constant time, whereas the <code>(++)</code> operator needs to walk the whole list, needing linear time. Thus the direct version uses linear time (<em>O(n)</em>) with respect to the length of the list, while the tail-recursive version is quadratic (<em>O(n²)</em>)!</p>
 <p>One might be tempted to fix this by using <code>(:)</code> in the tail-recursive version, but then the list would get generated in the reverse order. This could be fixed with an application of <code>reverse</code>, but that would make the resulting function quite complicated.</p>
 <p>There is another reason to prefer the direct version: laziness. We’ll get back to laziness in part 2 of the course, but for now it’s enough for you to know that <strong>the direct way of generating a list is simpler, more efficient and more idiomatic</strong>. You should try to practice it in the exercises. Check out the standard library implementations of <code>map</code> and <code>filter</code> above, even they produce the list directly without tail recursion!</p>
 <h2 id="something-fun-list-comprehensions"><span class="header-section-number">3.9</span> Something Fun: List Comprehensions</h2>
 <p>Haskell has <em>list comprehensions</em>, a nice syntax for defining lists that combines the power of <code>map</code> and <code>filter</code>. You might be familiar with Python’s list comprehensions already. Haskell’s work pretty much the same way, but their syntax is a bit different.</p>
 <p>Mapping:</p>
-<div class="sourceCode" id="cb239"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb239-1" data-line-number="1">[<span class="dv">2</span><span class="fu">*</span>i <span class="fu">|</span> i<span class="ot">&lt;-</span>[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]]</a>
-<a class="sourceLine" id="cb239-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb239"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb239-1" title="1">[<span class="dv">2</span><span class="fu">*</span>i <span class="fu">|</span> i<span class="ot">&lt;-</span>[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]]</a>
+<a class="sourceLine" id="cb239-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
 <p>Filtering:</p>
-<div class="sourceCode" id="cb240"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb240-1" data-line-number="1">[i <span class="fu">|</span> i <span class="ot">&lt;-</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">7</span>], even i]</a>
-<a class="sourceLine" id="cb240-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb240"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb240-1" title="1">[i <span class="fu">|</span> i <span class="ot">&lt;-</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">7</span>], <span class="fu">even</span> i]</a>
+<a class="sourceLine" id="cb240-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a></code></pre></div>
 <p>In general, these two forms are equivalent:</p>
-<div class="sourceCode" id="cb241"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb241-1" data-line-number="1">[f x <span class="fu">|</span> x <span class="ot">&lt;-</span> lis, p x]</a>
-<a class="sourceLine" id="cb241-2" data-line-number="2">map f (filter p lis)</a></code></pre></div>
+<div class="sourceCode" id="cb241"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb241-1" title="1">[f x <span class="fu">|</span> x <span class="ot">&lt;-</span> lis, p x]</a>
+<a class="sourceLine" id="cb241-2" title="2"><span class="fu">map</span> f (<span class="fu">filter</span> p lis)</a></code></pre></div>
 <p>List comprehensions can do even more. You can iterate over multiple lists:</p>
-<div class="sourceCode" id="cb242"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb242-1" data-line-number="1">[ first <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> last <span class="fu">|</span> first <span class="ot">&lt;-</span> [<span class="st">&quot;John&quot;</span>, <span class="st">&quot;Mary&quot;</span>], last <span class="ot">&lt;-</span> [<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;Cooper&quot;</span>] ]</a>
-<a class="sourceLine" id="cb242-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;John Smith&quot;</span>,<span class="st">&quot;John Cooper&quot;</span>,<span class="st">&quot;Mary Smith&quot;</span>,<span class="st">&quot;Mary Cooper&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb242"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb242-1" title="1">[ first <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> <span class="fu">last</span> <span class="fu">|</span> first <span class="ot">&lt;-</span> [<span class="st">&quot;John&quot;</span>, <span class="st">&quot;Mary&quot;</span>], <span class="fu">last</span> <span class="ot">&lt;-</span> [<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;Cooper&quot;</span>] ]</a>
+<a class="sourceLine" id="cb242-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;John Smith&quot;</span>,<span class="st">&quot;John Cooper&quot;</span>,<span class="st">&quot;Mary Smith&quot;</span>,<span class="st">&quot;Mary Cooper&quot;</span>]</a></code></pre></div>
 <p>You can make local defitions:</p>
-<div class="sourceCode" id="cb243"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb243-1" data-line-number="1">[ reversed <span class="fu">|</span> word <span class="ot">&lt;-</span> [<span class="st">&quot;this&quot;</span>,<span class="st">&quot;is&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;string&quot;</span>], <span class="kw">let</span> reversed <span class="fu">=</span> reverse word ]</a>
-<a class="sourceLine" id="cb243-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;siht&quot;</span>,<span class="st">&quot;si&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;gnirts&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb243"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb243-1" title="1">[ reversed <span class="fu">|</span> word <span class="ot">&lt;-</span> [<span class="st">&quot;this&quot;</span>,<span class="st">&quot;is&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;string&quot;</span>], <span class="kw">let</span> reversed <span class="fu">=</span> <span class="fu">reverse</span> word ]</a>
+<a class="sourceLine" id="cb243-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;siht&quot;</span>,<span class="st">&quot;si&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;gnirts&quot;</span>]</a></code></pre></div>
 <p>You can even do pattern matching in list comprehensions!</p>
-<div class="sourceCode" id="cb244"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb244-1" data-line-number="1">firstLetters string <span class="fu">=</span> [ char <span class="fu">|</span> (char<span class="fu">:</span>_) <span class="ot">&lt;-</span> words string ]</a></code></pre></div>
-<div class="sourceCode" id="cb245"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb245-1" data-line-number="1">firstLetters <span class="st">&quot;Hello World!&quot;</span></a>
-<a class="sourceLine" id="cb245-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="st">&quot;HW&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb244"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb244-1" title="1">firstLetters string <span class="fu">=</span> [ char <span class="fu">|</span> (char<span class="fu">:</span>_) <span class="ot">&lt;-</span> <span class="fu">words</span> string ]</a></code></pre></div>
+<div class="sourceCode" id="cb245"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb245-1" title="1">firstLetters <span class="st">&quot;Hello World!&quot;</span></a>
+<a class="sourceLine" id="cb245-2" title="2">  <span class="fu">==&gt;</span> <span class="st">&quot;HW&quot;</span></a></code></pre></div>
 <h2 id="something-fun-custom-operators"><span class="header-section-number">3.10</span> Something Fun: Custom Operators</h2>
 <p>In Haskell an <em>operator</em> is anything built from the characters <code>!#$%&amp;*+./&lt;=&gt;?@\^|-~</code>. Operators can be defined just like functions (note the slightly different type annotation):</p>
-<div class="sourceCode" id="cb246"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb246-1" data-line-number="1"><span class="ot">(&lt;+&gt;) ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb246-2" data-line-number="2">xs <span class="fu">&lt;+&gt;</span> ys <span class="fu">=</span> zipWith (<span class="fu">+</span>) xs ys</a></code></pre></div>
-<div class="sourceCode" id="cb247"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb247-1" data-line-number="1"><span class="ot">(+++) ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb247-2" data-line-number="2">a <span class="fu">+++</span> b <span class="fu">=</span> a <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb246"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb246-1" title="1"><span class="ot">(&lt;+&gt;) ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb246-2" title="2">xs <span class="fu">&lt;+&gt;</span> ys <span class="fu">=</span> <span class="fu">zipWith</span> (<span class="fu">+</span>) xs ys</a></code></pre></div>
+<div class="sourceCode" id="cb247"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb247-1" title="1"><span class="ot">(+++) ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb247-2" title="2">a <span class="fu">+++</span> b <span class="fu">=</span> a <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> b</a></code></pre></div>
 <h2 id="quiz-2"><span class="header-section-number">3.11</span> Quiz</h2>
 <p>What’s the type of this function? <code>both p q x = p x &amp;&amp; q x</code></p>
 <ol class="quiz">
@@ -2242,7 +2240,7 @@ unspecified
 <li><a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Set3b.hs">Set3b</a>: list recursion exercises</li>
 </ul>
 <h3 id="common-errors"><span class="header-section-number">3.12.1</span> Common Errors</h3>
-<div class="sourceCode" id="cb248"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb248-1" data-line-number="1"><span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> a) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a></code></pre></div>
+<div class="sourceCode" id="cb248"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb248-1" title="1"><span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> a) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a></code></pre></div>
 <p>You’ve probably tried to use <code>x==Nothing</code> to check if a value is <code>Nothing</code>. Use pattern matching instead. The reason for this error is that values of type <code>Maybe a</code> can’t be compared because Haskell doesn’t know how to compare values of the polymorphic type <code>a</code>. You’ll find more about this in the next lecture. Use pattern matching instead of <code>==</code> for now.</p>
 <h1 id="lecture-4-real-classy"><span class="header-section-number">4</span> Lecture 4: Real Classy</h1>
 <ul>
@@ -2275,53 +2273,53 @@ unspecified
 </tbody>
 </table>
 <p>To get values out of tuples, you can use the functions <code>fst</code> and <code>snd</code>:</p>
-<div class="sourceCode" id="cb249"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb249-1" data-line-number="1">fst<span class="ot"> ::</span> (a, b) <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb249-2" data-line-number="2">snd<span class="ot"> ::</span> (a, b) <span class="ot">-&gt;</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb249"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb249-1" title="1"><span class="fu">fst</span><span class="ot"> ::</span> (a, b) <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb249-2" title="2"><span class="fu">snd</span><span class="ot"> ::</span> (a, b) <span class="ot">-&gt;</span> b</a></code></pre></div>
 <p>You can also pattern match on tuples. This is often the most convenient way, and also works for tuples of larger sizes. The <code>fst</code> and <code>snd</code> functions work only on pairs.</p>
 <p>Tuples are very useful in combination with lists. Here are some examples using the <code>zip</code>, <code>unzip</code> and <code>partition</code> functions from the <code>Data.List</code> module.</p>
-<div class="sourceCode" id="cb250"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb250-1" data-line-number="1">zip<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [(a, b)]    <span class="co">-- two lists to list of pairs</span></a>
-<a class="sourceLine" id="cb250-2" data-line-number="2">unzip<span class="ot"> ::</span> [(a, b)] <span class="ot">-&gt;</span> ([a], [b])  <span class="co">-- list of pairs to pair of lists</span></a>
-<a class="sourceLine" id="cb250-3" data-line-number="3"><span class="ot">partition ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> ([a], [a])    <span class="co">-- elements that satisfy and don&#39;t satisfy a predicate</span></a></code></pre></div>
+<div class="sourceCode" id="cb250"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb250-1" title="1"><span class="fu">zip</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> [(a, b)]    <span class="co">-- two lists to list of pairs</span></a>
+<a class="sourceLine" id="cb250-2" title="2"><span class="fu">unzip</span><span class="ot"> ::</span> [(a, b)] <span class="ot">-&gt;</span> ([a], [b])  <span class="co">-- list of pairs to pair of lists</span></a>
+<a class="sourceLine" id="cb250-3" title="3"><span class="ot">partition ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> ([a], [a])    <span class="co">-- elements that satisfy and don&#39;t satisfy a predicate</span></a></code></pre></div>
 <!-- How about `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`? -->
-<div class="sourceCode" id="cb251"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb251-1" data-line-number="1">zip [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] [<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>]</a>
-<a class="sourceLine" id="cb251-2" data-line-number="2">  <span class="fu">==&gt;</span> [(<span class="dv">1</span>,<span class="dt">True</span>),(<span class="dv">2</span>,<span class="dt">False</span>),(<span class="dv">3</span>,<span class="dt">True</span>)]</a>
-<a class="sourceLine" id="cb251-3" data-line-number="3">unzip [(<span class="st">&quot;Fred&quot;</span>,<span class="dv">1</span>), (<span class="st">&quot;Jack&quot;</span>,<span class="dv">10</span>), (<span class="st">&quot;Helen&quot;</span>,<span class="dv">13</span>)]</a>
-<a class="sourceLine" id="cb251-4" data-line-number="4">  <span class="fu">==&gt;</span> ([<span class="st">&quot;Fred&quot;</span>,<span class="st">&quot;Jack&quot;</span>,<span class="st">&quot;Helen&quot;</span>],[<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">13</span>])</a>
-<a class="sourceLine" id="cb251-5" data-line-number="5">partition (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="fu">-</span><span class="dv">1</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb251-6" data-line-number="6">  <span class="fu">==&gt;</span> ([<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">2</span>],[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>])</a></code></pre></div>
+<div class="sourceCode" id="cb251"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb251-1" title="1"><span class="fu">zip</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] [<span class="dt">True</span>,<span class="dt">False</span>,<span class="dt">True</span>]</a>
+<a class="sourceLine" id="cb251-2" title="2">  <span class="fu">==&gt;</span> [(<span class="dv">1</span>,<span class="dt">True</span>),(<span class="dv">2</span>,<span class="dt">False</span>),(<span class="dv">3</span>,<span class="dt">True</span>)]</a>
+<a class="sourceLine" id="cb251-3" title="3"><span class="fu">unzip</span> [(<span class="st">&quot;Fred&quot;</span>,<span class="dv">1</span>), (<span class="st">&quot;Jack&quot;</span>,<span class="dv">10</span>), (<span class="st">&quot;Helen&quot;</span>,<span class="dv">13</span>)]</a>
+<a class="sourceLine" id="cb251-4" title="4">  <span class="fu">==&gt;</span> ([<span class="st">&quot;Fred&quot;</span>,<span class="st">&quot;Jack&quot;</span>,<span class="st">&quot;Helen&quot;</span>],[<span class="dv">1</span>,<span class="dv">10</span>,<span class="dv">13</span>])</a>
+<a class="sourceLine" id="cb251-5" title="5">partition (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="fu">-</span><span class="dv">1</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb251-6" title="6">  <span class="fu">==&gt;</span> ([<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">2</span>],[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>])</a></code></pre></div>
 <p>Here’s an example of pattern matching on tuples:</p>
-<div class="sourceCode" id="cb252"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb252-1" data-line-number="1"><span class="ot">swap ::</span> (a,b) <span class="ot">-&gt;</span> (b,a)</a>
-<a class="sourceLine" id="cb252-2" data-line-number="2">swap (x,y) <span class="fu">=</span> (y,x)</a></code></pre></div>
+<div class="sourceCode" id="cb252"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb252-1" title="1"><span class="ot">swap ::</span> (a,b) <span class="ot">-&gt;</span> (b,a)</a>
+<a class="sourceLine" id="cb252-2" title="2">swap (x,y) <span class="fu">=</span> (y,x)</a></code></pre></div>
 <p>Here’s an example of pattern matching on tuples and lists at the same time:</p>
-<div class="sourceCode" id="cb253"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb253-1" data-line-number="1"><span class="co">-- sum all numbers that are paired with True</span></a>
-<a class="sourceLine" id="cb253-2" data-line-number="2"><span class="ot">sumIf ::</span> [(<span class="dt">Bool</span>,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb253-3" data-line-number="3">sumIf [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb253-4" data-line-number="4">sumIf ((<span class="dt">True</span>,x)<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumIf xs</a>
-<a class="sourceLine" id="cb253-5" data-line-number="5">sumIf ((<span class="dt">False</span>,_)<span class="fu">:</span>xs) <span class="fu">=</span> sumIf xs</a></code></pre></div>
-<div class="sourceCode" id="cb254"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb254-1" data-line-number="1">sumIf [(<span class="dt">True</span>,<span class="dv">1</span>),(<span class="dt">False</span>,<span class="dv">10</span>),(<span class="dt">True</span>,<span class="dv">100</span>)]</a>
-<a class="sourceLine" id="cb254-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">101</span></a></code></pre></div>
+<div class="sourceCode" id="cb253"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb253-1" title="1"><span class="co">-- sum all numbers that are paired with True</span></a>
+<a class="sourceLine" id="cb253-2" title="2"><span class="ot">sumIf ::</span> [(<span class="dt">Bool</span>,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb253-3" title="3">sumIf [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb253-4" title="4">sumIf ((<span class="dt">True</span>,x)<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumIf xs</a>
+<a class="sourceLine" id="cb253-5" title="5">sumIf ((<span class="dt">False</span>,_)<span class="fu">:</span>xs) <span class="fu">=</span> sumIf xs</a></code></pre></div>
+<div class="sourceCode" id="cb254"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb254-1" title="1">sumIf [(<span class="dt">True</span>,<span class="dv">1</span>),(<span class="dt">False</span>,<span class="dv">10</span>),(<span class="dt">True</span>,<span class="dv">100</span>)]</a>
+<a class="sourceLine" id="cb254-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">101</span></a></code></pre></div>
 <h2 id="interlude-folding"><span class="header-section-number">4.2</span> Interlude: Folding</h2>
 <!-- TODO: should this be in the same section as foldable? -->
 <p>Consider the functions <code>sumNumbers :: [Int] -&gt; Int</code>, <code>myMaximum :: [Int] -&gt; Int</code>, and <code>countNothings :: [Maybe a] -&gt; Int</code> again.</p>
-<div class="sourceCode" id="cb255"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb255-1" data-line-number="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb255-2" data-line-number="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb255-3" data-line-number="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a>
-<a class="sourceLine" id="cb255-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb255-5" data-line-number="5"><span class="ot">myMaximum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb255-6" data-line-number="6">myMaximum [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb255-7" data-line-number="7">myMaximum (x<span class="fu">:</span>xs) <span class="fu">=</span> go x xs</a>
-<a class="sourceLine" id="cb255-8" data-line-number="8">  <span class="kw">where</span> go biggest [] <span class="fu">=</span> biggest</a>
-<a class="sourceLine" id="cb255-9" data-line-number="9">        go biggest (x<span class="fu">:</span>xs) <span class="fu">=</span> go (max biggest x) xs</a>
-<a class="sourceLine" id="cb255-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb255-11" data-line-number="11"><span class="ot">countNothings ::</span> [<span class="dt">Maybe</span> a] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb255-12" data-line-number="12">countNothings [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb255-13" data-line-number="13">countNothings (<span class="dt">Nothing</span> <span class="fu">:</span> xs) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> countNothings xs</a>
-<a class="sourceLine" id="cb255-14" data-line-number="14">countNothings (<span class="dt">Just</span> _  <span class="fu">:</span> xs) <span class="fu">=</span> countNothings xs</a></code></pre></div>
+<div class="sourceCode" id="cb255"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb255-1" title="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb255-2" title="2">sumNumbers [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb255-3" title="3">sumNumbers (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">+</span> sumNumbers xs</a>
+<a class="sourceLine" id="cb255-4" title="4"></a>
+<a class="sourceLine" id="cb255-5" title="5"><span class="ot">myMaximum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb255-6" title="6">myMaximum [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb255-7" title="7">myMaximum (x<span class="fu">:</span>xs) <span class="fu">=</span> go x xs</a>
+<a class="sourceLine" id="cb255-8" title="8">  <span class="kw">where</span> go biggest [] <span class="fu">=</span> biggest</a>
+<a class="sourceLine" id="cb255-9" title="9">        go biggest (x<span class="fu">:</span>xs) <span class="fu">=</span> go (<span class="fu">max</span> biggest x) xs</a>
+<a class="sourceLine" id="cb255-10" title="10"></a>
+<a class="sourceLine" id="cb255-11" title="11"><span class="ot">countNothings ::</span> [<span class="dt">Maybe</span> a] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb255-12" title="12">countNothings [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb255-13" title="13">countNothings (<span class="dt">Nothing</span> <span class="fu">:</span> xs) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> countNothings xs</a>
+<a class="sourceLine" id="cb255-14" title="14">countNothings (<span class="dt">Just</span> _  <span class="fu">:</span> xs) <span class="fu">=</span> countNothings xs</a></code></pre></div>
 <p>They have one common characteristic. They take a list and produce a value that depends on the values of the elements in the given list. They “crunch” or <em>fold</em> a list of many values into a single value.</p>
 <p>Prelude has a function called <code>foldr</code>, which performs a <em>right associative fold</em> over a <code>Foldable</code> data type. We’ll learn more about <code>Foldable</code> soon. At this point, it suffices to think of lists, so we define</p>
-<div class="sourceCode" id="cb256"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb256-1" data-line-number="1">foldr<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> b</a>
-<a class="sourceLine" id="cb256-2" data-line-number="2">foldr f y []     <span class="fu">=</span> y</a>
-<a class="sourceLine" id="cb256-3" data-line-number="3">foldr f y (x<span class="fu">:</span>xs) <span class="fu">=</span> f x (foldr f y xs)</a></code></pre></div>
+<div class="sourceCode" id="cb256"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb256-1" title="1"><span class="fu">foldr</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> b</a>
+<a class="sourceLine" id="cb256-2" title="2"><span class="fu">foldr</span> f y []     <span class="fu">=</span> y</a>
+<a class="sourceLine" id="cb256-3" title="3"><span class="fu">foldr</span> f y (x<span class="fu">:</span>xs) <span class="fu">=</span> f x (<span class="fu">foldr</span> f y xs)</a></code></pre></div>
 <p>What this definition says, is that for an empty list <code>[] :: [a]</code>, <code>foldr</code> returns the default value <code>y :: b</code>. For any other list <code>x : xs</code>, <code>foldr</code> applies <code>f</code> to <code>x</code> and the result of <code>foldr f y xs</code> (i.e. folding over the rest of the list). It’s a simple definition by recursion.</p>
 <p>In other words, <code>foldr</code> calls its argument function <code>f</code> repeatedly with two arguments.</p>
 <ul>
@@ -2342,11 +2340,11 @@ unspecified
 ```
 -->
 <p>The expression <code>foldr (+) 0 [1,2,3]</code> evaluates as follows:</p>
-<div class="sourceCode" id="cb257"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb257-1" data-line-number="1">foldr (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> foldr (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span><span class="dv">3</span><span class="fu">:</span>[])</a>
-<a class="sourceLine" id="cb257-2" data-line-number="2">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (foldr (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">2</span><span class="fu">:</span><span class="dv">3</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb257-3" data-line-number="3">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (foldr (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">3</span><span class="fu">:</span>[])))</a>
-<a class="sourceLine" id="cb257-4" data-line-number="4">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> (foldr (<span class="fu">+</span>) <span class="dv">0</span> [])))</a>
-<a class="sourceLine" id="cb257-5" data-line-number="5">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb257"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb257-1" title="1"><span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span><span class="dv">3</span><span class="fu">:</span>[])</a>
+<a class="sourceLine" id="cb257-2" title="2">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">2</span><span class="fu">:</span><span class="dv">3</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb257-3" title="3">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> (<span class="dv">3</span><span class="fu">:</span>[])))</a>
+<a class="sourceLine" id="cb257-4" title="4">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> (<span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [])))</a>
+<a class="sourceLine" id="cb257-5" title="5">                    <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>))</a></code></pre></div>
 <p>The result can be thought of as a tree:</p>
 <p><img src="img/sum123.svg" /></p>
 <!--
@@ -2361,12 +2359,12 @@ unspecified
 ```
 -->
 <p>One way to think about <code>foldr f y xs</code> is that it replaces the <code>(:)</code> operation with <code>f</code> and <code>[]</code> with <code>y</code>. In this case, <code>f</code> was <code>(+)</code> and <code>y</code> was <code>0</code>. If you write out how <code>sumNumbers [1,2,3]</code> behaves, you’ll notice that it performs the same computation as <code>foldr (+) 0 [1,2,3]</code> does! More generally:</p>
-<div class="sourceCode" id="cb258"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb258-1" data-line-number="1">sumNumbers xs <span class="fu">==</span> foldr (<span class="fu">+</span>) <span class="dv">0</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb258"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb258-1" title="1">sumNumbers xs <span class="fu">==</span> <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> xs</a></code></pre></div>
 <p>Those more experienced with math may notice that we can prove this claim by <em>induction</em>: Firstly, <code>sumNumbers [] ==&gt; 0</code> and <code>foldr (+) 0 [] ==&gt; 0</code>, so in the base case <code>sumNumbers [] == foldr (+) 0 []</code>. Next, we may assume as our induction hypothesis that <code>sumNumbers xs == foldr (+) 0 xs</code> for any list <code>xs</code>. Then, for the list <code>x:xs</code>, we have <code>sumNumbers (x:xs) ==&gt; x + sumNumbers xs</code>. Hence, <code>foldr (+) 0 (x:xs) ==&gt; x + foldr (+) 0 xs ==&gt; x + sumNumbers xs</code> by induction hypothesis. Therefore, by induction, the equation holds.</p>
 <p>You don’t need to read, write, or understand induction proofs in this course, but perhaps it is reassuring to know that properties and equalities of functions in Haskell can be (in principle) analysed mathematically, because Haskell is such a nice language. (Equalities and properties can be analysed in any programming language, but for Haskell, this analysis is especially convenient because Haskell is pure.)</p>
 <p>Another folding example is the <code>map</code> function:</p>
-<div class="sourceCode" id="cb259"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb259-1" data-line-number="1">map g xs <span class="fu">=</span> foldr helper [] xs</a>
-<a class="sourceLine" id="cb259-2" data-line-number="2">  <span class="kw">where</span> helper y ys <span class="fu">=</span> g y <span class="fu">:</span> ys</a></code></pre></div>
+<div class="sourceCode" id="cb259"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb259-1" title="1"><span class="fu">map</span> g xs <span class="fu">=</span> <span class="fu">foldr</span> helper [] xs</a>
+<a class="sourceLine" id="cb259-2" title="2">  <span class="kw">where</span> helper y ys <span class="fu">=</span> g y <span class="fu">:</span> ys</a></code></pre></div>
 <p>To see why this works, consider what <code>foldr helper [] [x1,x2,..,xn]</code> does:</p>
 <p><img src="img/foldr1.svg" /></p>
 <!-- Do these lists actually need to be finite? -->
@@ -2405,27 +2403,27 @@ unspecified
 <p>The resulting list, <code>[ g x1, g x2, g x3, ..., g xn ]</code>, is then exactly what we would have gotten with <code>map g xs</code>. (This could have been also proved by induction as we did for <code>sumNumbers</code>.) The lesson to take away is that folding is a particular, yet quite general, way to apply some transformation recursively into some structure (e.g. a list).</p>
 <h2 id="type-classes"><span class="header-section-number">4.3</span> Type Classes</h2>
 <p>How can Haskell’s <code>+</code> work on both <code>Int</code>s and <code>Double</code>s? Why can I compare all sorts of things with <code>==</code>? We’ve briefly mentioned constrained types earlier. Let’s see what they really mean. Let’s look at the types of <code>==</code> and <code>+</code>.</p>
-<div class="sourceCode" id="cb260"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb260-1" data-line-number="1"><span class="ot">(==) ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb260"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb260-1" title="1"><span class="ot">(==) ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>The type <code>(Eq a) =&gt; a -&gt; a -&gt; Bool</code> means: <em>for all types <code>a</code> that belong to the class <code>Eq</code>, this is a function of type <code>a -&gt; a -&gt; Bool</code></em>. That is, if the type <code>a</code> is a member of the class <code>Eq</code>, you can give two values of type <code>a</code> to <code>==</code> and get a <code>Bool</code> result.</p>
-<div class="sourceCode" id="cb261"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb261-1" data-line-number="1"><span class="ot">(+) ::</span> (<span class="dt">Num</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb261"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb261-1" title="1"><span class="ot">(+) ::</span> (<span class="dt">Num</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p>Similarly, the type <code>(Num a) =&gt; a -&gt; a -&gt; a</code> means: <em>for all types <code>a</code> that belong to the class <code>Num</code>, this is a function of type <code>a -&gt; a -&gt; a</code></em>. That is, you can give two values of the same type <code>a</code> to <code>+</code> and get out a third value of type <code>a</code>, as long as <code>a</code> is a member of <code>Num</code>.</p>
 <p><code>Num</code> and <code>Eq</code> are type classes. A <em>type class</em> is a way to group together types that support similar operations.</p>
 <p><strong>Note!</strong> A type class is a collection of types. It doesn’t have much to do with the classes of object oriented programming! In some situations, type classes can act like <em>interfaces</em> in object oriented programming. Unfortunately the functions in a type class are often called <em>methods</em>, adding to the confusion.</p>
 <p>PS. remember how using type variables for polymorphism was called <em>parametric polymorphism</em>? The fancy word for what type classes achieve is <em>ad-hoc polymorphism</em>. The difference is that with parametric polymorphism the function (e.g. <code>head</code>) has the same implementation for all types, whereas with ad-hoc polymorphisms there are multiple implementations (consider <code>==</code> on numbers and strings).</p>
 <h2 id="type-constraints"><span class="header-section-number">4.4</span> Type Constraints</h2>
 <p>When you’re working with a concrete type (not a type variable), you can just use type class functions (in this case, <code>(==)</code>):</p>
-<div class="sourceCode" id="cb262"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb262-1" data-line-number="1"><span class="ot">f ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb262-2" data-line-number="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
+<div class="sourceCode" id="cb262"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb262-1" title="1"><span class="ot">f ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb262-2" title="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
 <p>Of course, if the type in question isn’t a member of the right class, you get an error. For example:</p>
-<div class="sourceCode" id="cb263"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb263-1" data-line-number="1"><span class="ot">addTrue ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb263-2" data-line-number="2">addTrue b <span class="fu">=</span> b <span class="fu">+</span> <span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb263"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb263-1" title="1"><span class="ot">addTrue ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb263-2" title="2">addTrue b <span class="fu">=</span> b <span class="fu">+</span> <span class="dt">True</span></a></code></pre></div>
 <pre><code>error:
     • No instance for (Num Bool) arising from a use of ‘+’
     • In the expression: b + True
       In an equation for ‘addTrue’: addTrue b = b + True</code></pre>
 <p>However in a <em>polymorphic</em> function, you need to add <em>type constraints</em>. This doesn’t work:</p>
-<div class="sourceCode" id="cb265"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb265-1" data-line-number="1"><span class="ot">f ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb265-2" data-line-number="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
+<div class="sourceCode" id="cb265"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb265-1" title="1"><span class="ot">f ::</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb265-2" title="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
 <p>Luckily the error is nice:</p>
 <pre><code>error:
     • No instance for (Eq a) arising from a use of ‘==’
@@ -2436,230 +2434,230 @@ unspecified
     • In the expression: x == g x
       In an equation for ‘f’: f g x = x == g x</code></pre>
 <p>To signal that <code>f</code> only works on types that are members of the <code>Eq</code> class, we add a type constraint <code>(Eq a) =&gt;</code> to the type annotation.</p>
-<div class="sourceCode" id="cb267"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb267-1" data-line-number="1"><span class="ot">f ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb267-2" data-line-number="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
+<div class="sourceCode" id="cb267"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb267-1" title="1"><span class="ot">f ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb267-2" title="2">f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a></code></pre></div>
 <p>If you don’t have a type annotation, <em>type inference</em> can provide the constraints!</p>
-<div class="sourceCode" id="cb268"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb268-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a>
-<a class="sourceLine" id="cb268-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span><span class="kw">type</span> f</a>
-<a class="sourceLine" id="cb268-3" data-line-number="3"><span class="ot">f ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb268"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb268-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f g x <span class="fu">=</span> x <span class="fu">==</span> g x</a>
+<a class="sourceLine" id="cb268-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span><span class="kw">type</span> f</a>
+<a class="sourceLine" id="cb268-3" title="3"><span class="ot">f ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>You can also have multiple constraints:</p>
-<div class="sourceCode" id="cb269"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb269-1" data-line-number="1"><span class="ot">bothPairsEqual ::</span> (<span class="dt">Eq</span> a, <span class="dt">Eq</span> b) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb269-2" data-line-number="2">bothPairsEqual left1 left2 right1 right2 <span class="fu">=</span> left1 <span class="fu">==</span> left2 <span class="fu">&amp;&amp;</span> right1 <span class="fu">==</span> right2</a></code></pre></div>
+<div class="sourceCode" id="cb269"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb269-1" title="1"><span class="ot">bothPairsEqual ::</span> (<span class="dt">Eq</span> a, <span class="dt">Eq</span> b) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb269-2" title="2">bothPairsEqual left1 left2 right1 right2 <span class="fu">=</span> left1 <span class="fu">==</span> left2 <span class="fu">&amp;&amp;</span> right1 <span class="fu">==</span> right2</a></code></pre></div>
 <h2 id="standard-type-classes"><span class="header-section-number">4.5</span> Standard Type Classes</h2>
 <p>Here are some standard Haskell type classes you should know about.</p>
 <h3 id="eq"><span class="header-section-number">4.5.1</span> <code>Eq</code></h3>
 <p>We already saw the <code>Eq</code> class for equality comparisons. Here are the basic operations of the <code>Eq</code> class and some examples of their use. As you can see pretty much all the types we’ve seen so far, except for functions, are members of <code>Eq</code>.</p>
-<div class="sourceCode" id="cb270"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb270-1" data-line-number="1"><span class="ot">(==) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb270-2" data-line-number="2"><span class="ot">(/=) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
-<div class="sourceCode" id="cb271"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb271-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb271-2" data-line-number="2"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb271-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">/=</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb271-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb271-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;Foo&quot;</span> <span class="fu">==</span> <span class="st">&quot;Bar&quot;</span></a>
-<a class="sourceLine" id="cb271-6" data-line-number="6"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb271-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]] <span class="fu">==</span> [[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]]</a>
-<a class="sourceLine" id="cb271-8" data-line-number="8"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb271-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">1</span>) <span class="fu">==</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb271-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb271-11" data-line-number="11"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">5</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb271-12" data-line-number="12">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> (<span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span>))</a>
-<a class="sourceLine" id="cb271-13" data-line-number="13">        arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
-<a class="sourceLine" id="cb271-14" data-line-number="14">        (maybe you haven&#39;t applied a function to enough arguments<span class="fu">?</span>)</a>
-<a class="sourceLine" id="cb271-15" data-line-number="15">    • <span class="dt">In</span> the expression<span class="fu">:</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">==</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb271-16" data-line-number="16">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">==</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">2</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb270"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb270-1" title="1"><span class="ot">(==) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb270-2" title="2"><span class="ot">(/=) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb271"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb271-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb271-2" title="2"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb271-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span> <span class="fu">/=</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb271-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb271-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;Foo&quot;</span> <span class="fu">==</span> <span class="st">&quot;Bar&quot;</span></a>
+<a class="sourceLine" id="cb271-6" title="6"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb271-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]] <span class="fu">==</span> [[<span class="dv">1</span>,<span class="dv">2</span>],[<span class="dv">3</span>,<span class="dv">4</span>]]</a>
+<a class="sourceLine" id="cb271-8" title="8"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb271-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">1</span>) <span class="fu">==</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb271-10" title="10"></a>
+<a class="sourceLine" id="cb271-11" title="11"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">5</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb271-12" title="12">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> (<span class="dt">Integer</span> <span class="ot">-&gt;</span> <span class="dt">Integer</span>))</a>
+<a class="sourceLine" id="cb271-13" title="13">        arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
+<a class="sourceLine" id="cb271-14" title="14">        (<span class="fu">maybe</span> you haven&#39;t applied a function to enough arguments<span class="fu">?</span>)</a>
+<a class="sourceLine" id="cb271-15" title="15">    • <span class="dt">In</span> the expression<span class="fu">:</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">==</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb271-16" title="16">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">==</span> (\ x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">2</span>)</a></code></pre></div>
 <p>There are some other useful functions that use the <code>Eq</code> class, like <code>nub</code> from the module <code>Data.List</code>.</p>
-<div class="sourceCode" id="cb272"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb272-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
-<a class="sourceLine" id="cb272-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">:</span>t nub</a>
-<a class="sourceLine" id="cb272-3" data-line-number="3"><span class="ot">nub ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb272-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> nub [<span class="dv">3</span>,<span class="dv">5</span>,<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">1</span>]      <span class="co">-- eliminates duplicates</span></a>
-<a class="sourceLine" id="cb272-5" data-line-number="5">[<span class="dv">3</span>,<span class="dv">5</span>,<span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb272"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb272-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
+<a class="sourceLine" id="cb272-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">:</span>t nub</a>
+<a class="sourceLine" id="cb272-3" title="3"><span class="ot">nub ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb272-4" title="4"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> nub [<span class="dv">3</span>,<span class="dv">5</span>,<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">1</span>]      <span class="co">-- eliminates duplicates</span></a>
+<a class="sourceLine" id="cb272-5" title="5">[<span class="dv">3</span>,<span class="dv">5</span>,<span class="dv">1</span>]</a></code></pre></div>
 <h3 id="ord"><span class="header-section-number">4.5.2</span> <code>Ord</code></h3>
 <p>The <code>Ord</code> class is for ordering (less than, greater than). Again, here are the basic operations and some examples of their use. Note the new <code>Ordering</code> type. It has values <code>LT</code> for “less than”, <code>EQ</code> for “equal” and <code>GT</code> for “greater than”.</p>
-<div class="sourceCode" id="cb273"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb273-1" data-line-number="1">compare<span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
-<a class="sourceLine" id="cb273-2" data-line-number="2"><span class="ot">(&lt;) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb273-3" data-line-number="3"><span class="ot">(&gt;) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb273-4" data-line-number="4"><span class="ot">(&gt;=) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb273-5" data-line-number="5"><span class="ot">(&lt;=) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb273-6" data-line-number="6">max<span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb273-7" data-line-number="7">min<span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
-<div class="sourceCode" id="cb274"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb274-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> compare <span class="dv">1</span> <span class="dv">1</span>                <span class="co">-- 1 is EQual to 1</span></a>
-<a class="sourceLine" id="cb274-2" data-line-number="2"><span class="dt">EQ</span></a>
-<a class="sourceLine" id="cb274-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> compare <span class="dv">1</span> <span class="dv">3</span>                <span class="co">-- 1 is Less Than 3</span></a>
-<a class="sourceLine" id="cb274-4" data-line-number="4"><span class="dt">LT</span></a>
-<a class="sourceLine" id="cb274-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> compare <span class="dv">1</span> <span class="dv">0</span>                <span class="co">-- 1 is Greater Than 0</span></a>
-<a class="sourceLine" id="cb274-6" data-line-number="6"><span class="dt">GT</span></a>
-<a class="sourceLine" id="cb274-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> min <span class="dv">5</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb274-8" data-line-number="8"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb274-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> max <span class="dv">5</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb274-10" data-line-number="10"><span class="dv">5</span></a>
-<a class="sourceLine" id="cb274-11" data-line-number="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;aardvark&quot;</span> <span class="fu">&lt;</span> <span class="st">&quot;banana&quot;</span>      <span class="co">-- strings are compared alphabetically</span></a>
-<a class="sourceLine" id="cb274-12" data-line-number="12"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb274-13" data-line-number="13"><span class="dt">Prelude</span><span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;</span> [<span class="dv">2</span>,<span class="dv">5</span>]            <span class="co">-- lists are compared like strings</span></a>
-<a class="sourceLine" id="cb274-14" data-line-number="14"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb274-15" data-line-number="15"><span class="dt">Prelude</span><span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb274-16" data-line-number="16"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb273"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb273-1" title="1"><span class="fu">compare</span><span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
+<a class="sourceLine" id="cb273-2" title="2"><span class="ot">(&lt;) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb273-3" title="3"><span class="ot">(&gt;) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb273-4" title="4"><span class="ot">(&gt;=) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb273-5" title="5"><span class="ot">(&lt;=) ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb273-6" title="6"><span class="fu">max</span><span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb273-7" title="7"><span class="fu">min</span><span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb274"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb274-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">compare</span> <span class="dv">1</span> <span class="dv">1</span>                <span class="co">-- 1 is EQual to 1</span></a>
+<a class="sourceLine" id="cb274-2" title="2"><span class="dt">EQ</span></a>
+<a class="sourceLine" id="cb274-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">compare</span> <span class="dv">1</span> <span class="dv">3</span>                <span class="co">-- 1 is Less Than 3</span></a>
+<a class="sourceLine" id="cb274-4" title="4"><span class="dt">LT</span></a>
+<a class="sourceLine" id="cb274-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">compare</span> <span class="dv">1</span> <span class="dv">0</span>                <span class="co">-- 1 is Greater Than 0</span></a>
+<a class="sourceLine" id="cb274-6" title="6"><span class="dt">GT</span></a>
+<a class="sourceLine" id="cb274-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">min</span> <span class="dv">5</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb274-8" title="8"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb274-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">max</span> <span class="dv">5</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb274-10" title="10"><span class="dv">5</span></a>
+<a class="sourceLine" id="cb274-11" title="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="st">&quot;aardvark&quot;</span> <span class="fu">&lt;</span> <span class="st">&quot;banana&quot;</span>      <span class="co">-- strings are compared alphabetically</span></a>
+<a class="sourceLine" id="cb274-12" title="12"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb274-13" title="13"><span class="dt">Prelude</span><span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;</span> [<span class="dv">2</span>,<span class="dv">5</span>]            <span class="co">-- lists are compared like strings</span></a>
+<a class="sourceLine" id="cb274-14" title="14"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb274-15" title="15"><span class="dt">Prelude</span><span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;</span> [<span class="dv">1</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb274-16" title="16"><span class="dt">True</span></a></code></pre></div>
 <p>When we can compare values, we can also sort lists of them. The function <code>sort</code> from <code>Data.List</code> works on all types that belong to the <code>Ord</code> class.</p>
-<div class="sourceCode" id="cb275"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb275-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
-<a class="sourceLine" id="cb275-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">:</span>t sort</a>
-<a class="sourceLine" id="cb275-3" data-line-number="3">sort<span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb275-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort [<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">8</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb275-5" data-line-number="5">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>,<span class="dv">8</span>]</a>
-<a class="sourceLine" id="cb275-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort <span class="st">&quot;black sphinx of quartz, judge my vow!&quot;</span>     <span class="co">-- remember, strings are lists!</span></a>
-<a class="sourceLine" id="cb275-7" data-line-number="7"><span class="st">&quot;      !,aabcdefghijklmnoopqrstuuvwxyz&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb275"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb275-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.List</span></a>
+<a class="sourceLine" id="cb275-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">sort</span></a>
+<a class="sourceLine" id="cb275-3" title="3"><span class="fu">sort</span><span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb275-4" title="4"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> [<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">8</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb275-5" title="5">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>,<span class="dv">8</span>]</a>
+<a class="sourceLine" id="cb275-6" title="6"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> <span class="st">&quot;black sphinx of quartz, judge my vow!&quot;</span>     <span class="co">-- remember, strings are lists!</span></a>
+<a class="sourceLine" id="cb275-7" title="7"><span class="st">&quot;      !,aabcdefghijklmnoopqrstuuvwxyz&quot;</span></a></code></pre></div>
 <p>As a last example, let’s sort a list of lists according to length. We’ll need two helper functions:</p>
-<div class="sourceCode" id="cb276"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb276-1" data-line-number="1"><span class="co">-- from the module Data.Ord</span></a>
-<a class="sourceLine" id="cb276-2" data-line-number="2"><span class="co">-- compares two values &quot;through&quot; the function f</span></a>
-<a class="sourceLine" id="cb276-3" data-line-number="3"><span class="ot">comparing ::</span> (<span class="dt">Ord</span> a) <span class="ot">=&gt;</span> (b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
-<a class="sourceLine" id="cb276-4" data-line-number="4">comparing f x y <span class="fu">=</span> compare (f x) (f y)</a>
-<a class="sourceLine" id="cb276-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb276-6" data-line-number="6"><span class="co">-- from the module Data.List</span></a>
-<a class="sourceLine" id="cb276-7" data-line-number="7"><span class="co">-- sorts a list using the given comparison function</span></a>
-<a class="sourceLine" id="cb276-8" data-line-number="8"><span class="ot">sortBy ::</span> (a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb276"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb276-1" title="1"><span class="co">-- from the module Data.Ord</span></a>
+<a class="sourceLine" id="cb276-2" title="2"><span class="co">-- compares two values &quot;through&quot; the function f</span></a>
+<a class="sourceLine" id="cb276-3" title="3"><span class="ot">comparing ::</span> (<span class="dt">Ord</span> a) <span class="ot">=&gt;</span> (b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
+<a class="sourceLine" id="cb276-4" title="4">comparing f x y <span class="fu">=</span> <span class="fu">compare</span> (f x) (f y)</a>
+<a class="sourceLine" id="cb276-5" title="5"></a>
+<a class="sourceLine" id="cb276-6" title="6"><span class="co">-- from the module Data.List</span></a>
+<a class="sourceLine" id="cb276-7" title="7"><span class="co">-- sorts a list using the given comparison function</span></a>
+<a class="sourceLine" id="cb276-8" title="8"><span class="ot">sortBy ::</span> (a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>Now the implementation of <code>sortByLength</code> is straightforward:</p>
-<div class="sourceCode" id="cb277"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb277-1" data-line-number="1"><span class="co">-- sorts lists by their length</span></a>
-<a class="sourceLine" id="cb277-2" data-line-number="2"><span class="ot">sortByLength ::</span> [[a]] <span class="ot">-&gt;</span> [[a]]</a>
-<a class="sourceLine" id="cb277-3" data-line-number="3">sortByLength <span class="fu">=</span> sortBy (comparing length)</a></code></pre></div>
-<div class="sourceCode" id="cb278"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb278-1" data-line-number="1">sortByLength [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>]]   <span class="fu">==&gt;</span>  [[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>]]</a></code></pre></div>
+<div class="sourceCode" id="cb277"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb277-1" title="1"><span class="co">-- sorts lists by their length</span></a>
+<a class="sourceLine" id="cb277-2" title="2"><span class="ot">sortByLength ::</span> [[a]] <span class="ot">-&gt;</span> [[a]]</a>
+<a class="sourceLine" id="cb277-3" title="3">sortByLength <span class="fu">=</span> sortBy (comparing <span class="fu">length</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb278"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb278-1" title="1">sortByLength [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>]]   <span class="fu">==&gt;</span>  [[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>]]</a></code></pre></div>
 <h3 id="num-integral-fractional-floating"><span class="header-section-number">4.5.3</span> <code>Num</code>, <code>Integral</code>, <code>Fractional</code>, <code>Floating</code></h3>
 <p>The <code>Num</code> class contains integer arithmetic:</p>
-<div class="sourceCode" id="cb279"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb279-1" data-line-number="1"><span class="ot">(+) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb279-2" data-line-number="2"><span class="ot">(-) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb279-3" data-line-number="3"><span class="ot">(*) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb279-4" data-line-number="4">negate<span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a    <span class="co">-- 0-x</span></a>
-<a class="sourceLine" id="cb279-5" data-line-number="5">abs<span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a       <span class="co">-- absolute value</span></a>
-<a class="sourceLine" id="cb279-6" data-line-number="6">signum<span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a    <span class="co">-- -1 for negative values, 0 for 0, +1 for positive values</span></a>
-<a class="sourceLine" id="cb279-7" data-line-number="7">fromInteger<span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb279"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb279-1" title="1"><span class="ot">(+) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb279-2" title="2"><span class="ot">(-) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb279-3" title="3"><span class="ot">(*) ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb279-4" title="4"><span class="fu">negate</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a    <span class="co">-- 0-x</span></a>
+<a class="sourceLine" id="cb279-5" title="5"><span class="fu">abs</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a       <span class="co">-- absolute value</span></a>
+<a class="sourceLine" id="cb279-6" title="6"><span class="fu">signum</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a    <span class="co">-- -1 for negative values, 0 for 0, +1 for positive values</span></a>
+<a class="sourceLine" id="cb279-7" title="7"><span class="fu">fromInteger</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p><code>Num</code> also shows up in the types of integer literals:</p>
-<div class="sourceCode" id="cb280"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb280-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dv">12</span></a>
-<a class="sourceLine" id="cb280-2" data-line-number="2"><span class="dv">12</span><span class="ot"> ::</span> <span class="dt">Num</span> p <span class="ot">=&gt;</span> p</a></code></pre></div>
+<div class="sourceCode" id="cb280"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb280-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dv">12</span></a>
+<a class="sourceLine" id="cb280-2" title="2"><span class="dv">12</span><span class="ot"> ::</span> <span class="dt">Num</span> p <span class="ot">=&gt;</span> p</a></code></pre></div>
 <p>This means that a literal like <code>12</code> can be interpreted as a member of any type implementing <code>Num</code>. When GHC reads a number literal like, <code>12</code> it produces code that corresponds to <code>fromIntegral 12</code>.</p>
-<div class="sourceCode" id="cb281"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb281-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb281-2" data-line-number="2"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb281-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb281-4" data-line-number="4"><span class="fl">1.0</span></a>
-<a class="sourceLine" id="cb281-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> fromIntegral <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb281-6" data-line-number="6"><span class="fl">1.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb281"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb281-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb281-2" title="2"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb281-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb281-4" title="4"><span class="fl">1.0</span></a>
+<a class="sourceLine" id="cb281-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">fromIntegral</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb281-6" title="6"><span class="fl">1.0</span></a></code></pre></div>
 <p><code>Integral</code> is the class of types that represent whole numbers, like <code>Int</code> and <code>Integer</code>. The most interesting functions are <code>div</code> and <code>mod</code> for integer division and remainder. All types that belong to <code>Integral</code> also belong to <code>Num</code>.</p>
-<div class="sourceCode" id="cb282"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb282-1" data-line-number="1">div<span class="ot"> ::</span> <span class="dt">Integral</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb282-2" data-line-number="2">mod<span class="ot"> ::</span> <span class="dt">Integral</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb282"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb282-1" title="1"><span class="fu">div</span><span class="ot"> ::</span> <span class="dt">Integral</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb282-2" title="2"><span class="fu">mod</span><span class="ot"> ::</span> <span class="dt">Integral</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p><code>Fractional</code> is the class for types that have division. All types that belong to <code>Fractional</code> also belong to <code>Num</code>.</p>
-<div class="sourceCode" id="cb283"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb283-1" data-line-number="1"><span class="ot">(/) ::</span> <span class="dt">Fractional</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb283"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb283-1" title="1"><span class="ot">(/) ::</span> <span class="dt">Fractional</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p><code>Floating</code> contains some additional operations that only make sense for floating point numbers. All types that belong to <code>Floating</code> also belong to <code>Fractional</code> (and to <code>Num</code>).</p>
-<div class="sourceCode" id="cb284"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb284-1" data-line-number="1">sqrt<span class="ot"> ::</span> <span class="dt">Floating</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb284-2" data-line-number="2">sin<span class="ot"> ::</span> <span class="dt">Floating</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb284"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb284-1" title="1"><span class="fu">sqrt</span><span class="ot"> ::</span> <span class="dt">Floating</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb284-2" title="2"><span class="fu">sin</span><span class="ot"> ::</span> <span class="dt">Floating</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
 <h3 id="read-and-show"><span class="header-section-number">4.5.4</span> <code>Read</code> and <code>Show</code></h3>
 <p>The <code>Show</code> and <code>Read</code> classes are for the functions <code>show</code> and <code>read</code>, that convert values to and from Strings.</p>
-<div class="sourceCode" id="cb285"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb285-1" data-line-number="1">show<span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb285-2" data-line-number="2">read<span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a</a></code></pre></div>
-<div class="sourceCode" id="cb286"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb286-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> show <span class="dv">3</span></a>
-<a class="sourceLine" id="cb286-2" data-line-number="2"><span class="st">&quot;3&quot;</span></a>
-<a class="sourceLine" id="cb286-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> read <span class="st">&quot;3&quot;</span><span class="ot"> ::</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb286-4" data-line-number="4"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb286-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> read <span class="st">&quot;3&quot;</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb286-6" data-line-number="6"><span class="fl">3.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb285"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb285-1" title="1"><span class="fu">show</span><span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb285-2" title="2"><span class="fu">read</span><span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb286"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb286-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">show</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb286-2" title="2"><span class="st">&quot;3&quot;</span></a>
+<a class="sourceLine" id="cb286-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">read</span> <span class="st">&quot;3&quot;</span><span class="ot"> ::</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb286-4" title="4"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb286-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">read</span> <span class="st">&quot;3&quot;</span><span class="ot"> ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb286-6" title="6"><span class="fl">3.0</span></a></code></pre></div>
 <p>As you can see above, you often need to use a type annotation with <code>read</code> so that the compiler can choose the right implementation.</p>
 <h3 id="sidenote-foldable"><span class="header-section-number">4.5.5</span> Sidenote: <code>Foldable</code></h3>
 <p>One more thing! You might remember that it was mentioned earlier that the type of <code>length</code> isn’t <code>[a] -&gt; Int</code> but something more general. Let’s have a look:</p>
-<div class="sourceCode" id="cb287"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb287-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t length</a>
-<a class="sourceLine" id="cb287-2" data-line-number="2">length<span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb287"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb287-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">length</span></a>
+<a class="sourceLine" id="cb287-2" title="2"><span class="fu">length</span><span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
 <p>This type looks a bit different than the ones we’ve seen before. The type variable <code>t</code> has an argument <code>a</code>. We’ll look at type classes like this in more detail in part 2, but here’s a crash course.</p>
 <p>What <code>Foldable</code> represents is types that you can fold over. The true type of <code>foldr</code> is:</p>
-<div class="sourceCode" id="cb288"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb288-1" data-line-number="1">foldr<span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb288"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb288-1" title="1"><span class="fu">foldr</span><span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> b</a></code></pre></div>
 <p>We’ve succesfully used the fact that lists are <code>Foldable</code> since we’ve managed to use <code>length</code> and <code>foldr</code> on lists. However, <code>Maybe</code> is also <code>Foldable</code>! The <code>Foldable</code> instance for <code>Maybe</code> just pretends that values of <code>Maybe a</code> are like lists of length 0 or 1:</p>
-<div class="sourceCode" id="cb289"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb289-1" data-line-number="1">foldr (<span class="fu">+</span>) <span class="dv">1</span> <span class="dt">Nothing</span>   <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb289-2" data-line-number="2">foldr (<span class="fu">+</span>) <span class="dv">1</span> (<span class="dt">Just</span> <span class="dv">3</span>)  <span class="fu">==&gt;</span> <span class="dv">4</span></a>
-<a class="sourceLine" id="cb289-3" data-line-number="3">length <span class="dt">Nothing</span>        <span class="fu">==&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb289-4" data-line-number="4">length (<span class="dt">Just</span> <span class="ch">&#39;a&#39;</span>)     <span class="fu">==&gt;</span> <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb289"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb289-1" title="1"><span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">1</span> <span class="dt">Nothing</span>   <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb289-2" title="2"><span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">1</span> (<span class="dt">Just</span> <span class="dv">3</span>)  <span class="fu">==&gt;</span> <span class="dv">4</span></a>
+<a class="sourceLine" id="cb289-3" title="3"><span class="fu">length</span> <span class="dt">Nothing</span>        <span class="fu">==&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb289-4" title="4"><span class="fu">length</span> (<span class="dt">Just</span> <span class="ch">&#39;a&#39;</span>)     <span class="fu">==&gt;</span> <span class="dv">1</span></a></code></pre></div>
 <p>We’ll meet some more foldable types next.</p>
 <h2 id="more-data-structures"><span class="header-section-number">4.6</span> More Data Structures</h2>
 <p>Now that we are familiar with the standard type classes, we can look at one of their applications: the <code>Map</code> and <code>Array</code> data structures.</p>
 <h3 id="data.map"><span class="header-section-number">4.6.1</span> <code>Data.Map</code></h3>
 <p>The <code>Data.Map</code> module defines the <code>Map</code> type. Maps are search trees for key-value pairs. One way to look at this is that a value of type <code>Map k v</code> is roughly the same as a value of type <code>[(k,v)]</code>, a list of pairs. However, the operations on a map are more efficient than operations on a list.</p>
 <p>Since <code>Data.Map</code> contains some function with the same names as <code>Prelude</code> functions, the namespace needs to be imported <em>qualified</em>:</p>
-<div class="sourceCode" id="cb290"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb290-1" data-line-number="1"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a></code></pre></div>
+<div class="sourceCode" id="cb290"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb290-1" title="1"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a></code></pre></div>
 <p>Now we can refer to the map type as <code>Map.Map</code>, and to various map functions like <code>Map.insert</code>. Here are the most important functions for maps:</p>
-<div class="sourceCode" id="cb291"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb291-1" data-line-number="1"><span class="co">-- Create a Map from a list of key-value pairs</span></a>
-<a class="sourceLine" id="cb291-2" data-line-number="2">Map.fromList<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> [(k, a)] <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a>
-<a class="sourceLine" id="cb291-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb291-4" data-line-number="4"><span class="co">-- Insert a value into a map. Overrides any previous value with the same key.</span></a>
-<a class="sourceLine" id="cb291-5" data-line-number="5"><span class="co">-- Returns a new map. Does not mutate the given map.</span></a>
-<a class="sourceLine" id="cb291-6" data-line-number="6">Map.insert<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> k <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a>
-<a class="sourceLine" id="cb291-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb291-8" data-line-number="8"><span class="co">-- Get a value from a map using a key. Returns Nothing if the key was not present in the map.</span></a>
-<a class="sourceLine" id="cb291-9" data-line-number="9">Map.lookup<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb291-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb291-11" data-line-number="11"><span class="co">-- An empty map</span></a>
-<a class="sourceLine" id="cb291-12" data-line-number="12">Map.empty<span class="ot"> ::</span> <span class="dt">Map.Map</span> k a</a></code></pre></div>
+<div class="sourceCode" id="cb291"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb291-1" title="1"><span class="co">-- Create a Map from a list of key-value pairs</span></a>
+<a class="sourceLine" id="cb291-2" title="2">Map.fromList<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> [(k, a)] <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a>
+<a class="sourceLine" id="cb291-3" title="3"></a>
+<a class="sourceLine" id="cb291-4" title="4"><span class="co">-- Insert a value into a map. Overrides any previous value with the same key.</span></a>
+<a class="sourceLine" id="cb291-5" title="5"><span class="co">-- Returns a new map. Does not mutate the given map.</span></a>
+<a class="sourceLine" id="cb291-6" title="6">Map.insert<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> k <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a>
+<a class="sourceLine" id="cb291-7" title="7"></a>
+<a class="sourceLine" id="cb291-8" title="8"><span class="co">-- Get a value from a map using a key. Returns Nothing if the key was not present in the map.</span></a>
+<a class="sourceLine" id="cb291-9" title="9">Map.lookup<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb291-10" title="10"></a>
+<a class="sourceLine" id="cb291-11" title="11"><span class="co">-- An empty map</span></a>
+<a class="sourceLine" id="cb291-12" title="12">Map.empty<span class="ot"> ::</span> <span class="dt">Map.Map</span> k a</a></code></pre></div>
 <p>The <code>Ord</code> constraint for the key type of the map is needed because maps are implemented as <em>ordered binary search trees</em>.</p>
 <p>Note that like all Haskell values, maps are <em>immutable</em> meaning you can’t change a map once you define it. However, map operations like <code>insert</code> produce a <em>new</em> map. To perform multiple map operations you need to reuse the return value. Here’s a GHCi session operating on a map.</p>
-<div class="sourceCode" id="cb292"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb292-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a>
-<a class="sourceLine" id="cb292-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> <span class="kw">let</span> values <span class="fu">=</span> Map.fromList [(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>),(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>)]</a>
-<a class="sourceLine" id="cb292-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.lookup <span class="st">&quot;z&quot;</span> values</a>
-<a class="sourceLine" id="cb292-4" data-line-number="4"><span class="dt">Just</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb292-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.lookup <span class="st">&quot;banana&quot;</span> values</a>
-<a class="sourceLine" id="cb292-6" data-line-number="6"><span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb292-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.insert <span class="st">&quot;x&quot;</span> <span class="dv">7</span> values</a>
-<a class="sourceLine" id="cb292-8" data-line-number="8">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;x&quot;</span>,<span class="dv">7</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
-<a class="sourceLine" id="cb292-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> values                                       <span class="co">-- note immutability!</span></a>
-<a class="sourceLine" id="cb292-10" data-line-number="10">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
-<a class="sourceLine" id="cb292-11" data-line-number="11"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.insert <span class="st">&quot;x&quot;</span> <span class="dv">1</span> (Map.insert <span class="st">&quot;y&quot;</span> <span class="dv">2</span> values)   <span class="co">-- two insertions</span></a>
-<a class="sourceLine" id="cb292-12" data-line-number="12">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;x&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;y&quot;</span>,<span class="dv">2</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
-<a class="sourceLine" id="cb292-13" data-line-number="13"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span></a></code></pre></div>
+<div class="sourceCode" id="cb292"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb292-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a>
+<a class="sourceLine" id="cb292-2" title="2"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> <span class="kw">let</span> values <span class="fu">=</span> Map.fromList [(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>),(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>)]</a>
+<a class="sourceLine" id="cb292-3" title="3"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.lookup <span class="st">&quot;z&quot;</span> values</a>
+<a class="sourceLine" id="cb292-4" title="4"><span class="dt">Just</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb292-5" title="5"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.lookup <span class="st">&quot;banana&quot;</span> values</a>
+<a class="sourceLine" id="cb292-6" title="6"><span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb292-7" title="7"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.insert <span class="st">&quot;x&quot;</span> <span class="dv">7</span> values</a>
+<a class="sourceLine" id="cb292-8" title="8">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;x&quot;</span>,<span class="dv">7</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
+<a class="sourceLine" id="cb292-9" title="9"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> values                                       <span class="co">-- note immutability!</span></a>
+<a class="sourceLine" id="cb292-10" title="10">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
+<a class="sourceLine" id="cb292-11" title="11"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span> Map.insert <span class="st">&quot;x&quot;</span> <span class="dv">1</span> (Map.insert <span class="st">&quot;y&quot;</span> <span class="dv">2</span> values)   <span class="co">-- two insertions</span></a>
+<a class="sourceLine" id="cb292-12" title="12">fromList [(<span class="st">&quot;w&quot;</span>,<span class="dv">4</span>),(<span class="st">&quot;x&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;y&quot;</span>,<span class="dv">2</span>),(<span class="st">&quot;z&quot;</span>,<span class="dv">3</span>)]</a>
+<a class="sourceLine" id="cb292-13" title="13"><span class="dt">Prelude</span> <span class="dt">Map</span><span class="fu">&gt;</span></a></code></pre></div>
 <p>Here’s an example of representing a bank as a <code>Map String Int</code> (map from account name to account balance), and withdrawing some money from an account:</p>
-<div class="sourceCode" id="cb293"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb293-1" data-line-number="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb293-2" data-line-number="2">withdraw account amount bank <span class="fu">=</span></a>
-<a class="sourceLine" id="cb293-3" data-line-number="3">  <span class="kw">case</span> Map.lookup account bank <span class="kw">of</span></a>
-<a class="sourceLine" id="cb293-4" data-line-number="4">    <span class="dt">Nothing</span>  <span class="ot">-&gt;</span> bank                                   <span class="co">-- account not found, no change</span></a>
-<a class="sourceLine" id="cb293-5" data-line-number="5">    <span class="dt">Just</span> sum <span class="ot">-&gt;</span> Map.insert account (sum<span class="fu">-</span>amount) bank   <span class="co">-- set new balance</span></a></code></pre></div>
+<div class="sourceCode" id="cb293"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb293-1" title="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb293-2" title="2">withdraw account amount bank <span class="fu">=</span></a>
+<a class="sourceLine" id="cb293-3" title="3">  <span class="kw">case</span> Map.lookup account bank <span class="kw">of</span></a>
+<a class="sourceLine" id="cb293-4" title="4">    <span class="dt">Nothing</span>  <span class="ot">-&gt;</span> bank                                   <span class="co">-- account not found, no change</span></a>
+<a class="sourceLine" id="cb293-5" title="5">    <span class="dt">Just</span> <span class="fu">sum</span> <span class="ot">-&gt;</span> Map.insert account (<span class="fu">sum-</span>amount) bank   <span class="co">-- set new balance</span></a></code></pre></div>
 <p>Here’s how you might use the <code>withdraw</code> function in <code>GHCi</code>. Note how the maps get printed as <code>fromList</code> invocations. Also note how calling <code>withdraw ... bank</code> returns a <em>new</em> bank and doesn’t change the existing bank.</p>
-<div class="sourceCode" id="cb294"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb294-1" data-line-number="1"><span class="dt">GHCi</span><span class="fu">&gt;</span> <span class="kw">let</span> bank <span class="fu">=</span> Map.fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
-<a class="sourceLine" id="cb294-2" data-line-number="2"><span class="dt">GHCi</span><span class="fu">&gt;</span> withdraw <span class="st">&quot;Bob&quot;</span> <span class="dv">80</span> bank</a>
-<a class="sourceLine" id="cb294-3" data-line-number="3">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">20</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
-<a class="sourceLine" id="cb294-4" data-line-number="4"><span class="dt">GHCi</span><span class="fu">&gt;</span> bank                         <span class="co">-- note immutability</span></a>
-<a class="sourceLine" id="cb294-5" data-line-number="5">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
-<a class="sourceLine" id="cb294-6" data-line-number="6"><span class="dt">GHCi</span><span class="fu">&gt;</span> withdraw <span class="st">&quot;Bozo&quot;</span> <span class="dv">1000</span> bank</a>
-<a class="sourceLine" id="cb294-7" data-line-number="7">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb294"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb294-1" title="1"><span class="dt">GHCi</span><span class="fu">&gt;</span> <span class="kw">let</span> bank <span class="fu">=</span> Map.fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
+<a class="sourceLine" id="cb294-2" title="2"><span class="dt">GHCi</span><span class="fu">&gt;</span> withdraw <span class="st">&quot;Bob&quot;</span> <span class="dv">80</span> bank</a>
+<a class="sourceLine" id="cb294-3" title="3">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">20</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
+<a class="sourceLine" id="cb294-4" title="4"><span class="dt">GHCi</span><span class="fu">&gt;</span> bank                         <span class="co">-- note immutability</span></a>
+<a class="sourceLine" id="cb294-5" title="5">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a>
+<a class="sourceLine" id="cb294-6" title="6"><span class="dt">GHCi</span><span class="fu">&gt;</span> withdraw <span class="st">&quot;Bozo&quot;</span> <span class="dv">1000</span> bank</a>
+<a class="sourceLine" id="cb294-7" title="7">fromList [(<span class="st">&quot;Bob&quot;</span>,<span class="dv">100</span>),(<span class="st">&quot;Mike&quot;</span>,<span class="dv">50</span>)]</a></code></pre></div>
 <p><code>Data.Map</code> defines all sorts of useful higher-order functions for updating maps. We can rewrite the <code>withdraw</code> function using <code>Data.Map.adjust</code>:</p>
-<div class="sourceCode" id="cb295"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb295-1" data-line-number="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb295-2" data-line-number="2">withdraw account amount bank <span class="fu">=</span> Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">-</span>amount) account bank</a></code></pre></div>
+<div class="sourceCode" id="cb295"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb295-1" title="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb295-2" title="2">withdraw account amount bank <span class="fu">=</span> Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">-</span>amount) account bank</a></code></pre></div>
 <p><strong>Note!</strong> There are separate <code>Data.Map.Strict</code> and <code>Data.Map.Lazy</code> implementations. When you import <code>Data.Map</code> you get <code>Data.Map.Lazy</code>. You can find the documentation for all the <code>Data.Map</code> functions in <a href="https://hackage.haskell.org/package/containers-0.6.2.1/docs/Data-Map-Lazy.html">the docs for <code>Data.Map.Lazy</code></a>. We won’t go into their differences here, but mostly you should use <code>Data.Map.Strict</code> in real code.</p>
 <h3 id="data.array"><span class="header-section-number">4.6.2</span> <code>Data.Array</code></h3>
 <p>Another type that works kind of like a list but is more efficient for some operations is the array. Arrays are familiar from many other programming languages, but Haskell arrays are a bit different.</p>
 <p>Unlike the <code>Data.Map</code> module, the <code>Data.Array</code> can just be imported normally:</p>
-<div class="sourceCode" id="cb296"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb296-1" data-line-number="1"><span class="kw">import</span> <span class="dt">Data.Array</span></a></code></pre></div>
+<div class="sourceCode" id="cb296"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb296-1" title="1"><span class="kw">import</span> <span class="dt">Data.Array</span></a></code></pre></div>
 <p>Now we can look at the type of the <code>array</code> function that constructs an array.</p>
-<div class="sourceCode" id="cb297"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb297-1" data-line-number="1"><span class="ot">array ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> (i, i) <span class="ot">-&gt;</span> [(i, e)] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
+<div class="sourceCode" id="cb297"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb297-1" title="1"><span class="ot">array ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> (i, i) <span class="ot">-&gt;</span> [(i, e)] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
 <p>There are a couple of things to notice here. First of all, the <code>Array</code> type is parameterized by <em>two</em> types: the index type and the element type. Most other programming languages only parameterize arrays with the element type, but the index type is always <code>int</code>. In Haskell, we can have, for example, an <code>Array Char Int</code>: an array indexed by characters, or <code>Array Bool String</code>, an array indexed by booleans, or even <code>Array (Int,Int) Int</code>, a two-dimensional array of ints.</p>
 <p>Not all types can be index types. Only types that are similar to integers are suitable. That is the reason for the <code>Ix i</code> class constraint. The <code>Ix</code> class collects all the types that can be used as array indexes.</p>
 <p>Secondly, the <code>array</code> function takes an extra <code>(i,i)</code> parameter. These are the minimun and maximum indexes of the array. Unlike some other languages, where arrays always start at index 0 or 1, in Haskell you can define an array that starts from 7 and goes to 11. So here’s that array:</p>
-<div class="sourceCode" id="cb298"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb298-1" data-line-number="1"><span class="ot">myArray ::</span> <span class="dt">Array</span> <span class="dt">Int</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb298-2" data-line-number="2">myArray <span class="fu">=</span> array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>), (<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>), (<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>), (<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>), (<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb298"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb298-1" title="1"><span class="ot">myArray ::</span> <span class="dt">Array</span> <span class="dt">Int</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb298-2" title="2">myArray <span class="fu">=</span> array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>), (<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>), (<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>), (<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>), (<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a></code></pre></div>
 <p>Listing all the indices and elements in order can be a bit cumbersome, so there’s also the <code>listArray</code> constructor that just takes a list of elements in order:</p>
-<div class="sourceCode" id="cb299"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb299-1" data-line-number="1"><span class="ot">listArray ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> (i, i) <span class="ot">-&gt;</span> [e] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
-<div class="sourceCode" id="cb300"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb300-1" data-line-number="1"><span class="ot">myArray ::</span> <span class="dt">Array</span> <span class="dt">Int</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb300-2" data-line-number="2">myArray <span class="fu">=</span> listArray (<span class="dv">7</span>,<span class="dv">11</span>) [<span class="st">&quot;seven&quot;</span>, <span class="st">&quot;eight&quot;</span>, <span class="st">&quot;nine&quot;</span>, <span class="st">&quot;ten&quot;</span>, <span class="st">&quot;ELEVEN&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb299"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb299-1" title="1"><span class="ot">listArray ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> (i, i) <span class="ot">-&gt;</span> [e] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
+<div class="sourceCode" id="cb300"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb300-1" title="1"><span class="ot">myArray ::</span> <span class="dt">Array</span> <span class="dt">Int</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb300-2" title="2">myArray <span class="fu">=</span> listArray (<span class="dv">7</span>,<span class="dv">11</span>) [<span class="st">&quot;seven&quot;</span>, <span class="st">&quot;eight&quot;</span>, <span class="st">&quot;nine&quot;</span>, <span class="st">&quot;ten&quot;</span>, <span class="st">&quot;ELEVEN&quot;</span>]</a></code></pre></div>
 <p>Arrays are used with two new operators:</p>
-<div class="sourceCode" id="cb301"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb301-1" data-line-number="1"><span class="co">-- Array lookup</span></a>
-<a class="sourceLine" id="cb301-2" data-line-number="2"><span class="ot">(!) ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> <span class="dt">Array</span> i e <span class="ot">-&gt;</span> i <span class="ot">-&gt;</span> e</a>
-<a class="sourceLine" id="cb301-3" data-line-number="3"><span class="co">-- Array update</span></a>
-<a class="sourceLine" id="cb301-4" data-line-number="4"><span class="ot">(//) ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> <span class="dt">Array</span> i e <span class="ot">-&gt;</span> [(i, e)] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
+<div class="sourceCode" id="cb301"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb301-1" title="1"><span class="co">-- Array lookup</span></a>
+<a class="sourceLine" id="cb301-2" title="2"><span class="ot">(!) ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> <span class="dt">Array</span> i e <span class="ot">-&gt;</span> i <span class="ot">-&gt;</span> e</a>
+<a class="sourceLine" id="cb301-3" title="3"><span class="co">-- Array update</span></a>
+<a class="sourceLine" id="cb301-4" title="4"><span class="ot">(//) ::</span> <span class="dt">Ix</span> i <span class="ot">=&gt;</span> <span class="dt">Array</span> i e <span class="ot">-&gt;</span> [(i, e)] <span class="ot">-&gt;</span> <span class="dt">Array</span> i e</a></code></pre></div>
 <p>Here’s an example <code>GHCi</code> session:</p>
-<div class="sourceCode" id="cb302"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb302-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Array</span></a>
-<a class="sourceLine" id="cb302-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> <span class="kw">let</span> myArray <span class="fu">=</span> listArray (<span class="dv">7</span>,<span class="dv">11</span>) [<span class="st">&quot;seven&quot;</span>, <span class="st">&quot;eight&quot;</span>, <span class="st">&quot;nine&quot;</span>, <span class="st">&quot;ten&quot;</span>, <span class="st">&quot;ELEVEN&quot;</span>]</a>
-<a class="sourceLine" id="cb302-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray</a>
-<a class="sourceLine" id="cb302-4" data-line-number="4">array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a>
-<a class="sourceLine" id="cb302-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray <span class="fu">!</span> <span class="dv">8</span></a>
-<a class="sourceLine" id="cb302-6" data-line-number="6"><span class="st">&quot;eight&quot;</span></a>
-<a class="sourceLine" id="cb302-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray <span class="fu">//</span> [(<span class="dv">8</span>,<span class="st">&quot;ocho&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nueve&quot;</span>)]</a>
-<a class="sourceLine" id="cb302-8" data-line-number="8">array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;ocho&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nueve&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb302"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb302-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Array</span></a>
+<a class="sourceLine" id="cb302-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> <span class="kw">let</span> myArray <span class="fu">=</span> listArray (<span class="dv">7</span>,<span class="dv">11</span>) [<span class="st">&quot;seven&quot;</span>, <span class="st">&quot;eight&quot;</span>, <span class="st">&quot;nine&quot;</span>, <span class="st">&quot;ten&quot;</span>, <span class="st">&quot;ELEVEN&quot;</span>]</a>
+<a class="sourceLine" id="cb302-3" title="3"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray</a>
+<a class="sourceLine" id="cb302-4" title="4">array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a>
+<a class="sourceLine" id="cb302-5" title="5"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray <span class="fu">!</span> <span class="dv">8</span></a>
+<a class="sourceLine" id="cb302-6" title="6"><span class="st">&quot;eight&quot;</span></a>
+<a class="sourceLine" id="cb302-7" title="7"><span class="dt">Prelude</span> <span class="dt">Data.Array</span><span class="fu">&gt;</span> myArray <span class="fu">//</span> [(<span class="dv">8</span>,<span class="st">&quot;ocho&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nueve&quot;</span>)]</a>
+<a class="sourceLine" id="cb302-8" title="8">array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;ocho&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nueve&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)]</a></code></pre></div>
 <p>You might be wondering why the <code>(//)</code> operator does multiple updates at once. The reason is the main weakness of Haskell arrays: immutability. Since arrays can’t be changed in place, <code>(//)</code> must copy the whole array. This is why in Haskell it’s often preferable to use lists or maps to store data that needs to be updated. However, arrays may still be useful when constructed once and then used for a large number of lookups. We’ll get back to how Haskell data structures work in the next lecture.</p>
 <p><strong>Note!</strong> In this course we’ll use only <code>Array</code>, a simple array type that’s specified in the Haskell standard. There are many other array types like the mutable <code>IOArray</code> and the somewhat obscure <code>DiffArray</code>. There are also type classes for arrays like <code>IArray</code> and <code>MArray</code>. In addition to arrays there is a <a href="https://hackage.haskell.org/package/vector">wide family of <code>Vector</code> types</a> that can be more practical than <code>Array</code> for real programs.</p>
 <h3 id="sidenote-folding-over-maps-arrays"><span class="header-section-number">4.6.3</span> Sidenote: Folding over Maps &amp; Arrays</h3>
 <p>The <code>Map</code> and <code>Array</code> type are instances of <code>Foldable</code> just like lists are! This means you can use functions like <code>length</code> and <code>foldr</code> on them:</p>
-<div class="sourceCode" id="cb303"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb303-1" data-line-number="1">length (array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)])</a>
-<a class="sourceLine" id="cb303-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb303-3" data-line-number="3">foldr (<span class="fu">+</span>) <span class="dv">0</span> (Map.fromList [(<span class="st">&quot;banana&quot;</span>,<span class="dv">3</span>),(<span class="st">&quot;egg&quot;</span>,<span class="dv">7</span>)])</a>
-<a class="sourceLine" id="cb303-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">10</span></a></code></pre></div>
+<div class="sourceCode" id="cb303"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb303-1" title="1"><span class="fu">length</span> (array (<span class="dv">7</span>,<span class="dv">11</span>) [(<span class="dv">7</span>,<span class="st">&quot;seven&quot;</span>),(<span class="dv">8</span>,<span class="st">&quot;eight&quot;</span>),(<span class="dv">9</span>,<span class="st">&quot;nine&quot;</span>),(<span class="dv">10</span>,<span class="st">&quot;ten&quot;</span>),(<span class="dv">11</span>,<span class="st">&quot;ELEVEN&quot;</span>)])</a>
+<a class="sourceLine" id="cb303-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb303-3" title="3"><span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> (Map.fromList [(<span class="st">&quot;banana&quot;</span>,<span class="dv">3</span>),(<span class="st">&quot;egg&quot;</span>,<span class="dv">7</span>)])</a>
+<a class="sourceLine" id="cb303-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">10</span></a></code></pre></div>
 <h2 id="reading-docs"><span class="header-section-number">4.7</span> Reading Docs</h2>
 <p>Haskell libraries tend to have pretty good docs. We’ve linked to docs via Hackage (<a href="https://hackage.haskell.org" class="uri">https://hackage.haskell.org</a>) previously, but it’s important to know how to find the docs by your self too. The tool for generating Haskell documentation is called <em>Haddock</em> so sometimes Haskell docs are referred to as <em>haddocks</em>.</p>
 <p>Hackage is the Haskell package repository (just like <a href="https://pypi.org/">PyPI</a> for Python, Maven Central for Java or <a href="https://npmjs.com">NPM</a> for Javascript). In addition to the actual packages, it hosts documentation for them. Most of the modules that we use on this course are in the package called <code>base</code>. You can browse the docs for the base package at <a href="https://hackage.haskell.org/package/base-4.14.1.0/" class="uri">https://hackage.haskell.org/package/base-4.14.1.0/</a>.</p>
@@ -2772,190 +2770,190 @@ It turns a list of pairs into a list of elements
 </ul>
 <h2 id="algebraic-datatypes"><span class="header-section-number">5.1</span> Algebraic Datatypes</h2>
 <p>Haskell has a system called <em>algebraic datatypes</em> for defining new types. This sounds fancy, but is rather simple. Let’s dive in by looking at the standard library definitions of some familiar types:</p>
-<div class="sourceCode" id="cb305"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb305-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb305-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Ordering</span> <span class="fu">=</span> <span class="dt">LT</span> <span class="fu">|</span> <span class="dt">EQ</span> <span class="fu">|</span> <span class="dt">GT</span></a></code></pre></div>
+<div class="sourceCode" id="cb305"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb305-1" title="1"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb305-2" title="2"><span class="kw">data</span> <span class="dt">Ordering</span> <span class="fu">=</span> <span class="dt">LT</span> <span class="fu">|</span> <span class="dt">EQ</span> <span class="fu">|</span> <span class="dt">GT</span></a></code></pre></div>
 <p>With this syntax you too can define types:</p>
-<div class="sourceCode" id="cb306"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb306-1" data-line-number="1"><span class="co">-- definition of a type with three values</span></a>
-<a class="sourceLine" id="cb306-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Red</span> <span class="fu">|</span> <span class="dt">Green</span> <span class="fu">|</span> <span class="dt">Blue</span></a>
-<a class="sourceLine" id="cb306-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb306-4" data-line-number="4"><span class="co">-- a function that uses pattern matching on our new type</span></a>
-<a class="sourceLine" id="cb306-5" data-line-number="5"><span class="ot">rgb ::</span> <span class="dt">Color</span> <span class="ot">-&gt;</span> [<span class="dt">Double</span>]</a>
-<a class="sourceLine" id="cb306-6" data-line-number="6">rgb <span class="dt">Red</span> <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb306-7" data-line-number="7">rgb <span class="dt">Green</span> <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb306-8" data-line-number="8">rgb <span class="dt">Blue</span> <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">1</span>]</a></code></pre></div>
-<div class="sourceCode" id="cb307"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb307-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Red</span></a>
-<a class="sourceLine" id="cb307-2" data-line-number="2"><span class="dt">Red</span><span class="ot"> ::</span> <span class="dt">Color</span></a>
-<a class="sourceLine" id="cb307-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t [<span class="dt">Red</span>,<span class="dt">Blue</span>,<span class="dt">Green</span>]</a>
-<a class="sourceLine" id="cb307-4" data-line-number="4">[<span class="dt">Red</span>,<span class="dt">Blue</span>,<span class="dt">Green</span>]<span class="ot"> ::</span> [<span class="dt">Color</span>]</a>
-<a class="sourceLine" id="cb307-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> rgb <span class="dt">Red</span></a>
-<a class="sourceLine" id="cb307-6" data-line-number="6">[<span class="fl">1.0</span>,<span class="fl">0.0</span>,<span class="fl">0.0</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb306"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb306-1" title="1"><span class="co">-- definition of a type with three values</span></a>
+<a class="sourceLine" id="cb306-2" title="2"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Red</span> <span class="fu">|</span> <span class="dt">Green</span> <span class="fu">|</span> <span class="dt">Blue</span></a>
+<a class="sourceLine" id="cb306-3" title="3"></a>
+<a class="sourceLine" id="cb306-4" title="4"><span class="co">-- a function that uses pattern matching on our new type</span></a>
+<a class="sourceLine" id="cb306-5" title="5"><span class="ot">rgb ::</span> <span class="dt">Color</span> <span class="ot">-&gt;</span> [<span class="dt">Double</span>]</a>
+<a class="sourceLine" id="cb306-6" title="6">rgb <span class="dt">Red</span> <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb306-7" title="7">rgb <span class="dt">Green</span> <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb306-8" title="8">rgb <span class="dt">Blue</span> <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb307"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb307-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Red</span></a>
+<a class="sourceLine" id="cb307-2" title="2"><span class="dt">Red</span><span class="ot"> ::</span> <span class="dt">Color</span></a>
+<a class="sourceLine" id="cb307-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t [<span class="dt">Red</span>,<span class="dt">Blue</span>,<span class="dt">Green</span>]</a>
+<a class="sourceLine" id="cb307-4" title="4">[<span class="dt">Red</span>,<span class="dt">Blue</span>,<span class="dt">Green</span>]<span class="ot"> ::</span> [<span class="dt">Color</span>]</a>
+<a class="sourceLine" id="cb307-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> rgb <span class="dt">Red</span></a>
+<a class="sourceLine" id="cb307-6" title="6">[<span class="fl">1.0</span>,<span class="fl">0.0</span>,<span class="fl">0.0</span>]</a></code></pre></div>
 <h3 id="fields"><span class="header-section-number">5.1.1</span> Fields</h3>
 <p>Types like <code>Bool</code>, <code>Ordering</code> and <code>Color</code> that just list a bunch of constants are called <em>enumerations</em> or <em>enums</em> in Haskell and other languages. Enums are useful, but you need other types as well. Here we define a type for reports containing an id number, a title, and a body:</p>
-<div class="sourceCode" id="cb308"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb308-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Report</span> <span class="fu">=</span> <span class="dt">ConstructReport</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb308"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb308-1" title="1"><span class="kw">data</span> <span class="dt">Report</span> <span class="fu">=</span> <span class="dt">ConstructReport</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span></a></code></pre></div>
 <p>This is how you create a report:</p>
-<div class="sourceCode" id="cb309"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb309-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">ConstructReport</span> <span class="dv">1</span> <span class="st">&quot;Title&quot;</span> <span class="st">&quot;This is the body.&quot;</span></a>
-<a class="sourceLine" id="cb309-2" data-line-number="2"><span class="dt">ConstructReport</span> <span class="dv">1</span> <span class="st">&quot;Title&quot;</span> <span class="st">&quot;This is the body.&quot;</span><span class="ot"> ::</span> <span class="dt">Report</span></a></code></pre></div>
+<div class="sourceCode" id="cb309"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb309-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">ConstructReport</span> <span class="dv">1</span> <span class="st">&quot;Title&quot;</span> <span class="st">&quot;This is the body.&quot;</span></a>
+<a class="sourceLine" id="cb309-2" title="2"><span class="dt">ConstructReport</span> <span class="dv">1</span> <span class="st">&quot;Title&quot;</span> <span class="st">&quot;This is the body.&quot;</span><span class="ot"> ::</span> <span class="dt">Report</span></a></code></pre></div>
 <p>You can access the fields with pattern matching:</p>
-<div class="sourceCode" id="cb310"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb310-1" data-line-number="1"><span class="ot">reportContents ::</span> <span class="dt">Report</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb310-2" data-line-number="2">reportContents (<span class="dt">ConstructReport</span> id title contents) <span class="fu">=</span> contents</a>
-<a class="sourceLine" id="cb310-3" data-line-number="3"><span class="ot">setReportContents ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Report</span> <span class="ot">-&gt;</span> <span class="dt">Report</span></a>
-<a class="sourceLine" id="cb310-4" data-line-number="4">setReportContents contents (<span class="dt">ConstructReport</span> id title _contents) <span class="fu">=</span> <span class="dt">ConstructReport</span> id title contents</a></code></pre></div>
+<div class="sourceCode" id="cb310"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb310-1" title="1"><span class="ot">reportContents ::</span> <span class="dt">Report</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb310-2" title="2">reportContents (<span class="dt">ConstructReport</span> <span class="fu">id</span> title contents) <span class="fu">=</span> contents</a>
+<a class="sourceLine" id="cb310-3" title="3"><span class="ot">setReportContents ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Report</span> <span class="ot">-&gt;</span> <span class="dt">Report</span></a>
+<a class="sourceLine" id="cb310-4" title="4">setReportContents contents (<span class="dt">ConstructReport</span> <span class="fu">id</span> title _contents) <span class="fu">=</span> <span class="dt">ConstructReport</span> <span class="fu">id</span> title contents</a></code></pre></div>
 <h3 id="constructors"><span class="header-section-number">5.1.2</span> Constructors</h3>
 <p>The things on the right hand side of a <code>data</code> declaration are called <em>constructors</em>. <code>True</code>, <code>False</code>, <code>Red</code> and <code>ConstructReport</code> are all examples of constructors. A type can have multiple constructors, and a constructor can have zero or more fields.</p>
 <p>Here is a datatype for a standard playing card. It has five constructors, of which <code>Joker</code> has zero fields and the others have one field.</p>
-<div class="sourceCode" id="cb311"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb311-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Card</span> <span class="fu">=</span> <span class="dt">Joker</span> <span class="fu">|</span> <span class="dt">Heart</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Club</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Spade</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Diamond</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb311"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb311-1" title="1"><span class="kw">data</span> <span class="dt">Card</span> <span class="fu">=</span> <span class="dt">Joker</span> <span class="fu">|</span> <span class="dt">Heart</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Club</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Spade</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Diamond</span> <span class="dt">Int</span></a></code></pre></div>
 <p>Constructors with fields have function type and can be used wherever functions can:</p>
-<div class="sourceCode" id="cb312"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb312-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Heart</span></a>
-<a class="sourceLine" id="cb312-2" data-line-number="2"><span class="dt">Heart</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Card</span></a>
-<a class="sourceLine" id="cb312-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Club</span></a>
-<a class="sourceLine" id="cb312-4" data-line-number="4"><span class="dt">Club</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Card</span></a>
-<a class="sourceLine" id="cb312-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> map <span class="dt">Heart</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb312-6" data-line-number="6">[<span class="dt">Heart</span> <span class="dv">1</span>,<span class="dt">Heart</span> <span class="dv">2</span>,<span class="dt">Heart</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb312-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (<span class="dt">Heart</span> <span class="fu">.</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">1</span>)) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb312-8" data-line-number="8"><span class="dt">Heart</span> <span class="dv">4</span></a></code></pre></div>
+<div class="sourceCode" id="cb312"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb312-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Heart</span></a>
+<a class="sourceLine" id="cb312-2" title="2"><span class="dt">Heart</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Card</span></a>
+<a class="sourceLine" id="cb312-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Club</span></a>
+<a class="sourceLine" id="cb312-4" title="4"><span class="dt">Club</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Card</span></a>
+<a class="sourceLine" id="cb312-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> <span class="dt">Heart</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb312-6" title="6">[<span class="dt">Heart</span> <span class="dv">1</span>,<span class="dt">Heart</span> <span class="dv">2</span>,<span class="dt">Heart</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb312-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (<span class="dt">Heart</span> <span class="fu">.</span> (\x <span class="ot">-&gt;</span> x<span class="fu">+</span><span class="dv">1</span>)) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb312-8" title="8"><span class="dt">Heart</span> <span class="dv">4</span></a></code></pre></div>
 <h3 id="sidenote-deriving"><span class="header-section-number">5.1.3</span> Sidenote: Deriving</h3>
 <p>By the way, there’s something missing from our <code>Card</code> type. Look at how it behaves compared to <code>Ordering</code> and <code>Bool</code>:</p>
-<div class="sourceCode" id="cb313"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb313-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">EQ</span></a>
-<a class="sourceLine" id="cb313-2" data-line-number="2"><span class="dt">EQ</span></a>
-<a class="sourceLine" id="cb313-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb313-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb313-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Joker</span></a>
-<a class="sourceLine" id="cb313-6" data-line-number="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">0</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb313-7" data-line-number="7">    <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Show</span> <span class="dt">Card</span>)</a>
-<a class="sourceLine" id="cb313-8" data-line-number="8">      arising from a use <span class="kw">of</span> <span class="ot">`print&#39; at &lt;interactive&gt;:1:0-4</span></a>
-<a class="sourceLine" id="cb313-9" data-line-number="9"><span class="ot">    Possible fix: add an instance declaration for (Show Card)</span></a>
-<a class="sourceLine" id="cb313-10" data-line-number="10"><span class="ot">    In a stmt of a &#39;do&#39; expression: print it</span></a></code></pre></div>
+<div class="sourceCode" id="cb313"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb313-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">EQ</span></a>
+<a class="sourceLine" id="cb313-2" title="2"><span class="dt">EQ</span></a>
+<a class="sourceLine" id="cb313-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb313-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb313-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Joker</span></a>
+<a class="sourceLine" id="cb313-6" title="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">0</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb313-7" title="7">    <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Show</span> <span class="dt">Card</span>)</a>
+<a class="sourceLine" id="cb313-8" title="8">      arising from a use <span class="kw">of</span> <span class="ot">`print&#39; at &lt;interactive&gt;:1:0-4</span></a>
+<a class="sourceLine" id="cb313-9" title="9"><span class="ot">    Possible fix: add an instance declaration for (Show Card)</span></a>
+<a class="sourceLine" id="cb313-10" title="10"><span class="ot">    In a stmt of a &#39;do&#39; expression: print it</span></a></code></pre></div>
 <p>The problem is that Haskell does not know how to print the types we defined. As the error says, they are not part of the <code>Show</code> class. The easy solution is to just add a <code>deriving Show</code> after the type definition:</p>
-<div class="sourceCode" id="cb314"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb314-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Card</span> <span class="fu">=</span> <span class="dt">Joker</span> <span class="fu">|</span> <span class="dt">Heart</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Club</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Spade</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Diamond</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb314-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
-<div class="sourceCode" id="cb315"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb315-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Joker</span></a>
-<a class="sourceLine" id="cb315-2" data-line-number="2"><span class="dt">Joker</span></a></code></pre></div>
+<div class="sourceCode" id="cb314"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb314-1" title="1"><span class="kw">data</span> <span class="dt">Card</span> <span class="fu">=</span> <span class="dt">Joker</span> <span class="fu">|</span> <span class="dt">Heart</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Club</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Spade</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Diamond</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb314-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
+<div class="sourceCode" id="cb315"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb315-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Joker</span></a>
+<a class="sourceLine" id="cb315-2" title="2"><span class="dt">Joker</span></a></code></pre></div>
 <p>The <code>deriving</code> syntax is a way to automatically make your class a member of certain basic type classes, most notably <code>Read</code>, <code>Show</code> and <code>Eq</code>. We’ll talk more about what this means later.</p>
 <h3 id="algebraic"><span class="header-section-number">5.1.4</span> Algebraic?</h3>
 <p>So why are these datatypes called algebraic? This is because, theoretically speaking, each datatype can be a <em>sum</em> of constructors, and each constructor is a <em>product</em> of fields. It makes sense to think of these as sums and products for many reasons, one being that we can count the possible values of each type this way:</p>
-<div class="sourceCode" id="cb316"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb316-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span>            <span class="co">-- corresponds to 1+1. Has 2 possible values.</span></a>
-<a class="sourceLine" id="cb316-2" data-line-number="2"><span class="kw">data</span> <span class="dt">TwoBools</span> <span class="fu">=</span> <span class="dt">TwoBools</span> <span class="dt">Bool</span> <span class="dt">Bool</span>  <span class="co">-- corresponds to Bool*Bool, i.e. 2*2. Has 4 possible values.</span></a>
-<a class="sourceLine" id="cb316-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Complex</span> <span class="fu">=</span> <span class="dt">Two</span> <span class="dt">Bool</span> <span class="dt">Bool</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Bool</span> <span class="fu">|</span> <span class="dt">None</span></a>
-<a class="sourceLine" id="cb316-4" data-line-number="4">                                    <span class="co">-- corresponds to Bool*Bool+Bool+1 = 2*2+2+1 = 7. Has 7 possible values.</span></a></code></pre></div>
+<div class="sourceCode" id="cb316"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb316-1" title="1"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span>            <span class="co">-- corresponds to 1+1. Has 2 possible values.</span></a>
+<a class="sourceLine" id="cb316-2" title="2"><span class="kw">data</span> <span class="dt">TwoBools</span> <span class="fu">=</span> <span class="dt">TwoBools</span> <span class="dt">Bool</span> <span class="dt">Bool</span>  <span class="co">-- corresponds to Bool*Bool, i.e. 2*2. Has 4 possible values.</span></a>
+<a class="sourceLine" id="cb316-3" title="3"><span class="kw">data</span> <span class="dt">Complex</span> <span class="fu">=</span> <span class="dt">Two</span> <span class="dt">Bool</span> <span class="dt">Bool</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Bool</span> <span class="fu">|</span> <span class="dt">None</span></a>
+<a class="sourceLine" id="cb316-4" title="4">                                    <span class="co">-- corresponds to Bool*Bool+Bool+1 = 2*2+2+1 = 7. Has 7 possible values.</span></a></code></pre></div>
 <p>There is a rich theory of algebraic datatypes. If you’re interested, you might find more info <a href="https://codewords.recurse.com/issues/three/algebra-and-calculus-of-algebraic-data-types">here</a> or <a href="https://www.cis.upenn.edu/~sweirich/papers/yorgey-thesis.pdf">here</a>.</p>
 <h2 id="type-parameters"><span class="header-section-number">5.2</span> Type Parameters</h2>
 <p>We introduced type parameters and parametric polymorphism when introducing lists in Lecture 2. Since then, we’ve seen other parameterized types like <code>Maybe</code> and <code>Either</code>. Now we’ll learn how we can define our own parameterized types.</p>
 <h3 id="defining-parameterized-types"><span class="header-section-number">5.2.1</span> Defining Parameterized Types</h3>
 <p>The definition for <code>Maybe</code> is:</p>
-<div class="sourceCode" id="cb317"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb317-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Maybe</span> a <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb317"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb317-1" title="1"><span class="kw">data</span> <span class="dt">Maybe</span> a <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> a</a></code></pre></div>
 <p>What’s <code>a</code>? We define a parameterized type by mentioning a <em>type variable</em> (<code>a</code> in this case) on the left side of the <code>=</code> sign. We can then use the same type variable in fields for our constructors. This is analogous to polymorphic functions. Instead of defining separate functions</p>
-<div class="sourceCode" id="cb318"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb318-1" data-line-number="1"><span class="ot">headInt ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb318-2" data-line-number="2"><span class="ot">headBool ::</span> [<span class="dt">Bool</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb318"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb318-1" title="1"><span class="ot">headInt ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb318-2" title="2"><span class="ot">headBool ::</span> [<span class="dt">Bool</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>and so on, we define one function <code>head :: [a] -&gt; a</code> that works for all types <code>a</code>. Similarly, instead of defining multiple types</p>
-<div class="sourceCode" id="cb319"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb319-1" data-line-number="1"><span class="kw">data</span> <span class="dt">MaybeInt</span> <span class="fu">=</span> <span class="dt">NothingInt</span> <span class="fu">|</span> <span class="dt">JustInt</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb319-2" data-line-number="2"><span class="kw">data</span> <span class="dt">MaybeBool</span> <span class="fu">=</span> <span class="dt">NothingBool</span> <span class="fu">|</span> <span class="dt">JustBool</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb319"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb319-1" title="1"><span class="kw">data</span> <span class="dt">MaybeInt</span> <span class="fu">=</span> <span class="dt">NothingInt</span> <span class="fu">|</span> <span class="dt">JustInt</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb319-2" title="2"><span class="kw">data</span> <span class="dt">MaybeBool</span> <span class="fu">=</span> <span class="dt">NothingBool</span> <span class="fu">|</span> <span class="dt">JustBool</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>we define one type <code>Maybe a</code> that works for all types <code>a</code>.</p>
 <p>Here’s our first own parameterized type <code>Described</code>. The values of type <code>Described a</code> contain a value of type <code>a</code> and a <code>String</code> description.</p>
-<div class="sourceCode" id="cb320"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb320-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Described</span> a <span class="fu">=</span> <span class="dt">Describe</span> a <span class="dt">String</span></a>
-<a class="sourceLine" id="cb320-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb320-3" data-line-number="3"><span class="ot">getValue ::</span> <span class="dt">Described</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb320-4" data-line-number="4">getValue (<span class="dt">Describe</span> x _) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb320-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb320-6" data-line-number="6"><span class="ot">getDescription ::</span> <span class="dt">Described</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb320-7" data-line-number="7">getDescription (<span class="dt">Describe</span> _ desc) <span class="fu">=</span> desc</a></code></pre></div>
-<div class="sourceCode" id="cb321"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb321-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Describe</span></a>
-<a class="sourceLine" id="cb321-2" data-line-number="2"><span class="dt">Describe</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Described</span> a</a>
-<a class="sourceLine" id="cb321-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Describe</span> <span class="dt">True</span> <span class="st">&quot;This is true&quot;</span></a>
-<a class="sourceLine" id="cb321-4" data-line-number="4"><span class="dt">Describe</span> <span class="dt">True</span> <span class="st">&quot;This is true&quot;</span><span class="ot"> ::</span> <span class="dt">Described</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb321-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> getValue (<span class="dt">Describe</span> <span class="dv">3</span> <span class="st">&quot;a number&quot;</span>)</a>
-<a class="sourceLine" id="cb321-6" data-line-number="6"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb321-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> getDescription (<span class="dt">Describe</span> <span class="dv">3</span> <span class="st">&quot;a number&quot;</span>)</a>
-<a class="sourceLine" id="cb321-8" data-line-number="8"><span class="st">&quot;a number&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb320"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb320-1" title="1"><span class="kw">data</span> <span class="dt">Described</span> a <span class="fu">=</span> <span class="dt">Describe</span> a <span class="dt">String</span></a>
+<a class="sourceLine" id="cb320-2" title="2"></a>
+<a class="sourceLine" id="cb320-3" title="3"><span class="ot">getValue ::</span> <span class="dt">Described</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb320-4" title="4">getValue (<span class="dt">Describe</span> x _) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb320-5" title="5"></a>
+<a class="sourceLine" id="cb320-6" title="6"><span class="ot">getDescription ::</span> <span class="dt">Described</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb320-7" title="7">getDescription (<span class="dt">Describe</span> _ desc) <span class="fu">=</span> desc</a></code></pre></div>
+<div class="sourceCode" id="cb321"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb321-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Describe</span></a>
+<a class="sourceLine" id="cb321-2" title="2"><span class="dt">Describe</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Described</span> a</a>
+<a class="sourceLine" id="cb321-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Describe</span> <span class="dt">True</span> <span class="st">&quot;This is true&quot;</span></a>
+<a class="sourceLine" id="cb321-4" title="4"><span class="dt">Describe</span> <span class="dt">True</span> <span class="st">&quot;This is true&quot;</span><span class="ot"> ::</span> <span class="dt">Described</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb321-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> getValue (<span class="dt">Describe</span> <span class="dv">3</span> <span class="st">&quot;a number&quot;</span>)</a>
+<a class="sourceLine" id="cb321-6" title="6"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb321-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> getDescription (<span class="dt">Describe</span> <span class="dv">3</span> <span class="st">&quot;a number&quot;</span>)</a>
+<a class="sourceLine" id="cb321-8" title="8"><span class="st">&quot;a number&quot;</span></a></code></pre></div>
 <h3 id="syntactic-note"><span class="header-section-number">5.2.2</span> Syntactic Note</h3>
 <p>In the above definitions, we’ve used <code>a</code> as a type variable. However any word that starts with a lower case letter is fine. We could have defined <code>Maybe</code> like this:</p>
-<div class="sourceCode" id="cb322"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb322-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Maybe</span> theType <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> theType</a></code></pre></div>
+<div class="sourceCode" id="cb322"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb322-1" title="1"><span class="kw">data</span> <span class="dt">Maybe</span> theType <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> theType</a></code></pre></div>
 <p>The rules for Haskell identifiers are:</p>
 <ul>
 <li>Type variables and names for functions and values start lower case (e.g. <code>a</code>, <code>map</code>, <code>xs</code>)</li>
 <li>Type names and constructor names start with upper case (e.g. <code>Maybe</code>, <code>Just</code>, <code>Card</code>, <code>Heart</code>)</li>
 </ul>
 <p>Note that a type and its constructor can have the same name. This is very common in Haskell code for types that only have one constructor. In this material we try to avoid it to avoid confusion. Here are some examples:</p>
-<div class="sourceCode" id="cb323"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb323-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">Pair</span> a a</a>
-<a class="sourceLine" id="cb323-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Report</span> <span class="fu">=</span> <span class="dt">Report</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span></a></code></pre></div>
-<div class="sourceCode" id="cb324"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb324-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Pair</span></a>
-<a class="sourceLine" id="cb324-2" data-line-number="2"><span class="dt">Pair</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Pair</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb323"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb323-1" title="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">Pair</span> a a</a>
+<a class="sourceLine" id="cb323-2" title="2"><span class="kw">data</span> <span class="dt">Report</span> <span class="fu">=</span> <span class="dt">Report</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb324"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb324-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Pair</span></a>
+<a class="sourceLine" id="cb324-2" title="2"><span class="dt">Pair</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Pair</span> a</a></code></pre></div>
 <p>Beware of mixing up types and constructors. Luckily types and constructors can never occur in the same context, so you get a nice error:</p>
-<div class="sourceCode" id="cb325"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb325-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Maybe</span>                              <span class="co">-- trying to use a type name as a value</span></a>
-<a class="sourceLine" id="cb325-2" data-line-number="2"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb325-3" data-line-number="3">    • <span class="dt">Data</span> constructor not <span class="kw">in</span> scope<span class="fu">:</span> <span class="dt">Maybe</span></a>
-<a class="sourceLine" id="cb325-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb325-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> undefined ::</span> <span class="dt">Nothing</span>               <span class="co">-- trying to use a constructor as a type</span></a>
-<a class="sourceLine" id="cb325-6" data-line-number="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">2</span><span class="fu">:</span><span class="dv">14</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb325-7" data-line-number="7">    <span class="dt">Not</span> <span class="kw">in</span> scope<span class="fu">:</span> <span class="kw">type</span> constructor or <span class="kw">class</span> ‘<span class="dt">Nothing</span>’</a></code></pre></div>
+<div class="sourceCode" id="cb325"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb325-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Maybe</span>                              <span class="co">-- trying to use a type name as a value</span></a>
+<a class="sourceLine" id="cb325-2" title="2"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb325-3" title="3">    • <span class="dt">Data</span> constructor <span class="fu">not</span> <span class="kw">in</span> scope<span class="fu">:</span> <span class="dt">Maybe</span></a>
+<a class="sourceLine" id="cb325-4" title="4"></a>
+<a class="sourceLine" id="cb325-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> undefined ::</span> <span class="dt">Nothing</span>               <span class="co">-- trying to use a constructor as a type</span></a>
+<a class="sourceLine" id="cb325-6" title="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">2</span><span class="fu">:</span><span class="dv">14</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb325-7" title="7">    <span class="dt">Not</span> <span class="kw">in</span> scope<span class="fu">:</span> <span class="kw">type</span> constructor <span class="fu">or</span> <span class="kw">class</span> ‘<span class="dt">Nothing</span>’</a></code></pre></div>
 <h3 id="sidenote-multiple-type-parameters"><span class="header-section-number">5.2.3</span> Sidenote: Multiple Type Parameters</h3>
 <p>Types can have multiple type parameters. The syntax is similar to defining functions with many arguments. Here’s the definition of the standard <code>Either</code> type:</p>
-<div class="sourceCode" id="cb326"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb326-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Either</span> a b <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Right</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb326"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb326-1" title="1"><span class="kw">data</span> <span class="dt">Either</span> a b <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Right</span> b</a></code></pre></div>
 <h2 id="recursive-types"><span class="header-section-number">5.3</span> Recursive Types</h2>
 <p>So far, all of the types we’ve defined have been of constant size. We can represent one report or one colour, but how could we represent a collection of things? We could use lists of course, but could we define a list type ourselves?</p>
 <p>Just like Haskell functions, Haskell data types can be <em>recursive</em>. This is no weirder than having an object in Java or Python that refers to another object of the same class. This is how you define a list of integers:</p>
-<div class="sourceCode" id="cb327"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb327-1" data-line-number="1"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
-<a class="sourceLine" id="cb327-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb327-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb327-4" data-line-number="4"><span class="ot">ihead ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb327-5" data-line-number="5">ihead (<span class="dt">Node</span> i _) <span class="fu">=</span> i</a>
-<a class="sourceLine" id="cb327-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb327-7" data-line-number="7"><span class="ot">itail ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">IntList</span></a>
-<a class="sourceLine" id="cb327-8" data-line-number="8">itail (<span class="dt">Node</span> _ t) <span class="fu">=</span> t</a>
-<a class="sourceLine" id="cb327-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb327-10" data-line-number="10"><span class="ot">ilength ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb327-11" data-line-number="11">ilength <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb327-12" data-line-number="12">ilength (<span class="dt">Node</span> _ t) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> ilength t</a></code></pre></div>
+<div class="sourceCode" id="cb327"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb327-1" title="1"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
+<a class="sourceLine" id="cb327-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb327-3" title="3"></a>
+<a class="sourceLine" id="cb327-4" title="4"><span class="ot">ihead ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb327-5" title="5">ihead (<span class="dt">Node</span> i _) <span class="fu">=</span> i</a>
+<a class="sourceLine" id="cb327-6" title="6"></a>
+<a class="sourceLine" id="cb327-7" title="7"><span class="ot">itail ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">IntList</span></a>
+<a class="sourceLine" id="cb327-8" title="8">itail (<span class="dt">Node</span> _ t) <span class="fu">=</span> t</a>
+<a class="sourceLine" id="cb327-9" title="9"></a>
+<a class="sourceLine" id="cb327-10" title="10"><span class="ot">ilength ::</span> <span class="dt">IntList</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb327-11" title="11">ilength <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb327-12" title="12">ilength (<span class="dt">Node</span> _ t) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> ilength t</a></code></pre></div>
 <p>We can use the functions defined above to work with lists of integers:</p>
-<div class="sourceCode" id="cb328"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb328-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> ihead (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
-<a class="sourceLine" id="cb328-2" data-line-number="2"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb328-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> itail (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
-<a class="sourceLine" id="cb328-4" data-line-number="4"><span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb328-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> ilength (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
-<a class="sourceLine" id="cb328-6" data-line-number="6"><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb328"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb328-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> ihead (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
+<a class="sourceLine" id="cb328-2" title="2"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb328-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> itail (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
+<a class="sourceLine" id="cb328-4" title="4"><span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb328-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> ilength (<span class="dt">Node</span> <span class="dv">3</span> (<span class="dt">Node</span> <span class="dv">5</span> (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span>)))</a>
+<a class="sourceLine" id="cb328-6" title="6"><span class="dv">3</span></a></code></pre></div>
 <p>Note that we can’t put values other than <code>Int</code>s inside our <code>IntList</code>:</p>
-<div class="sourceCode" id="cb329"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb329-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb329-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb329-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">3</span><span class="fu">:</span><span class="dv">6</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb329-4" data-line-number="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">Int</span>’ with actual <span class="kw">type</span> ‘<span class="dt">Bool</span>’</a>
-<a class="sourceLine" id="cb329-5" data-line-number="5">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘<span class="dt">Node</span>’, namely ‘<span class="dt">False</span>’</a>
-<a class="sourceLine" id="cb329-6" data-line-number="6">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb329-7" data-line-number="7">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a></code></pre></div>
+<div class="sourceCode" id="cb329"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb329-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb329-2" title="2"></a>
+<a class="sourceLine" id="cb329-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">3</span><span class="fu">:</span><span class="dv">6</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb329-4" title="4">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">Int</span>’ with actual <span class="kw">type</span> ‘<span class="dt">Bool</span>’</a>
+<a class="sourceLine" id="cb329-5" title="5">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘<span class="dt">Node</span>’, namely ‘<span class="dt">False</span>’</a>
+<a class="sourceLine" id="cb329-6" title="6">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb329-7" title="7">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a></code></pre></div>
 <p>To be able to put any type of element in our list, let’s do the same thing with a type parameter. This is the same as the built in type <code>[a]</code>, but with slightly clunkier syntax:</p>
-<div class="sourceCode" id="cb330"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb330-1" data-line-number="1"><span class="kw">data</span> <span class="dt">List</span> a <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">List</span> a)</a>
-<a class="sourceLine" id="cb330-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
+<div class="sourceCode" id="cb330"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb330-1" title="1"><span class="kw">data</span> <span class="dt">List</span> a <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">List</span> a)</a>
+<a class="sourceLine" id="cb330-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
 <p>Note how we need to pass the the type parameter <code>a</code> onwards in the recursion. We need to write <code>Node a (List a)</code> instead of <code>Node a List</code>. The <code>Node</code> constructor has two arguments. The first has type <code>a</code>, and the second has type <code>List a</code>. Here are the reimplementations of some standard list functions for our <code>List</code> type:</p>
-<div class="sourceCode" id="cb331"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb331-1" data-line-number="1"><span class="ot">lhead ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb331-2" data-line-number="2">lhead (<span class="dt">Node</span> h _) <span class="fu">=</span> h</a>
-<a class="sourceLine" id="cb331-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb331-4" data-line-number="4"><span class="ot">ltail ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">List</span> a</a>
-<a class="sourceLine" id="cb331-5" data-line-number="5">ltail (<span class="dt">Node</span> _ t) <span class="fu">=</span> t</a>
-<a class="sourceLine" id="cb331-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb331-7" data-line-number="7"><span class="ot">lnull ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb331-8" data-line-number="8">lnull <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb331-9" data-line-number="9">lnull _     <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb331-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb331-11" data-line-number="11"><span class="ot">llength ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb331-12" data-line-number="12">llength <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb331-13" data-line-number="13">llength (<span class="dt">Node</span> _ t) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> llength t</a></code></pre></div>
-<div class="sourceCode" id="cb332"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb332-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> lhead (<span class="dt">Node</span> <span class="dt">True</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb332-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb332-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> ltail (<span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span>))</a>
-<a class="sourceLine" id="cb332-4" data-line-number="4"><span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb332-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> lnull <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb332-6" data-line-number="6"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb331"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb331-1" title="1"><span class="ot">lhead ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb331-2" title="2">lhead (<span class="dt">Node</span> h _) <span class="fu">=</span> h</a>
+<a class="sourceLine" id="cb331-3" title="3"></a>
+<a class="sourceLine" id="cb331-4" title="4"><span class="ot">ltail ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">List</span> a</a>
+<a class="sourceLine" id="cb331-5" title="5">ltail (<span class="dt">Node</span> _ t) <span class="fu">=</span> t</a>
+<a class="sourceLine" id="cb331-6" title="6"></a>
+<a class="sourceLine" id="cb331-7" title="7"><span class="ot">lnull ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb331-8" title="8">lnull <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb331-9" title="9">lnull _     <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb331-10" title="10"></a>
+<a class="sourceLine" id="cb331-11" title="11"><span class="ot">llength ::</span> <span class="dt">List</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb331-12" title="12">llength <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb331-13" title="13">llength (<span class="dt">Node</span> _ t) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> llength t</a></code></pre></div>
+<div class="sourceCode" id="cb332"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb332-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> lhead (<span class="dt">Node</span> <span class="dt">True</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb332-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb332-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> ltail (<span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span>))</a>
+<a class="sourceLine" id="cb332-4" title="4"><span class="dt">Node</span> <span class="dt">False</span> <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb332-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> lnull <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb332-6" title="6"><span class="dt">True</span></a></code></pre></div>
 <p>Note that just like with normal Haskell lists, we can’t have elements of different types in the same list:</p>
-<div class="sourceCode" id="cb333"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb333-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb333-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb333-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">5</span><span class="fu">:</span><span class="dv">12</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb333-4" data-line-number="4">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘[<span class="dt">Char</span>]’ with ‘<span class="dt">Bool</span>’</a>
-<a class="sourceLine" id="cb333-5" data-line-number="5">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">List</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb333-6" data-line-number="6">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">List</span> [<span class="dt">Char</span>]</a>
-<a class="sourceLine" id="cb333-7" data-line-number="7">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘<span class="dt">Node</span>’, namely ‘(<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)’</a>
-<a class="sourceLine" id="cb333-8" data-line-number="8">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb333-9" data-line-number="9">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb333"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb333-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb333-2" title="2"></a>
+<a class="sourceLine" id="cb333-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">5</span><span class="fu">:</span><span class="dv">12</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb333-4" title="4">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘[<span class="dt">Char</span>]’ with ‘<span class="dt">Bool</span>’</a>
+<a class="sourceLine" id="cb333-5" title="5">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">List</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb333-6" title="6">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">List</span> [<span class="dt">Char</span>]</a>
+<a class="sourceLine" id="cb333-7" title="7">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘<span class="dt">Node</span>’, namely ‘(<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)’</a>
+<a class="sourceLine" id="cb333-8" title="8">      <span class="dt">In</span> the expression<span class="fu">:</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb333-9" title="9">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> <span class="dt">Node</span> <span class="dt">True</span> (<span class="dt">Node</span> <span class="st">&quot;foo&quot;</span> <span class="dt">Empty</span>)</a></code></pre></div>
 <h3 id="example-growing-a-tree"><span class="header-section-number">5.3.1</span> Example: Growing a Tree</h3>
 <p>Just like a list, we can also represent a binary tree:</p>
-<div class="sourceCode" id="cb334"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb334-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a) <span class="fu">|</span> <span class="dt">Empty</span></a></code></pre></div>
+<div class="sourceCode" id="cb334"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb334-1" title="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a) <span class="fu">|</span> <span class="dt">Empty</span></a></code></pre></div>
 <p>Our tree contains nodes, which contain a value of type <code>a</code> and two child trees, and empty trees.</p>
 <p>In case you’re not familiar with binary trees, they’re a data structure that’s often used as the basis for other data structures (<code>Data.Map</code> is based on trees!). Binary trees are often drawn as (upside-down) pictures, like this:</p>
 <p><img src="img/binaryTree.svg" /></p>
@@ -2969,122 +2967,122 @@ It turns a list of pairs into a list of elements
 ```
 -->
 <p>The highest node in the tree is called the <em>root</em> (<code>0</code> in this case), and the nodes with no children are called <code>leaves</code> (<code>2</code>, <code>3</code> and <code>4</code> in this case). We can define this tree using our <code>Tree</code> type like this:</p>
-<div class="sourceCode" id="cb335"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb335-1" data-line-number="1"><span class="ot">example ::</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb335-2" data-line-number="2">example <span class="fu">=</span> (<span class="dt">Node</span> <span class="dv">0</span> (<span class="dt">Node</span> <span class="dv">1</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb335-3" data-line-number="3">                          (<span class="dt">Node</span> <span class="dv">3</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
-<a class="sourceLine" id="cb335-4" data-line-number="4">                  (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb335"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb335-1" title="1"><span class="ot">example ::</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb335-2" title="2">example <span class="fu">=</span> (<span class="dt">Node</span> <span class="dv">0</span> (<span class="dt">Node</span> <span class="dv">1</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb335-3" title="3">                          (<span class="dt">Node</span> <span class="dv">3</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
+<a class="sourceLine" id="cb335-4" title="4">                  (<span class="dt">Node</span> <span class="dv">4</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a></code></pre></div>
 <p>The height of a binary tree is length of the longest path from the root to a leaf. In Haskell terms, it’s how many nested levels of <code>Node</code> constructors you need to build the tree. The height of our example tree is 3. Here’s a function that computes the height of a tree:</p>
-<div class="sourceCode" id="cb336"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb336-1" data-line-number="1"><span class="ot">treeHeight ::</span> <span class="dt">Tree</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb336-2" data-line-number="2">treeHeight <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb336-3" data-line-number="3">treeHeight (<span class="dt">Node</span> _ l r) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> max (treeHeight l) (treeHeight r)</a></code></pre></div>
-<div class="sourceCode" id="cb337"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb337-1" data-line-number="1">treeHeight <span class="dt">Empty</span> <span class="fu">==&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb337-2" data-line-number="2">treeHeight (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb337-3" data-line-number="3">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max (treeHeight <span class="dt">Empty</span>) (treeHeight <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb337-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max <span class="dv">0</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb337-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb337-6" data-line-number="6">treeHeight (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
-<a class="sourceLine" id="cb337-7" data-line-number="7">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max (treeHeight <span class="dt">Empty</span>) (treeHeight (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
-<a class="sourceLine" id="cb337-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max <span class="dv">0</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb337-9" data-line-number="9">  <span class="fu">==&gt;</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb337-10" data-line-number="10">treeHeight (<span class="dt">Node</span> <span class="dv">0</span> (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)) <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb337-11" data-line-number="11">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max (treeHeight (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))) (treeHeight <span class="dt">Empty</span>)</a>
-<a class="sourceLine" id="cb337-12" data-line-number="12">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> max <span class="dv">2</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb337-13" data-line-number="13">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb336"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb336-1" title="1"><span class="ot">treeHeight ::</span> <span class="dt">Tree</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb336-2" title="2">treeHeight <span class="dt">Empty</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb336-3" title="3">treeHeight (<span class="dt">Node</span> _ l r) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> (treeHeight l) (treeHeight r)</a></code></pre></div>
+<div class="sourceCode" id="cb337"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb337-1" title="1">treeHeight <span class="dt">Empty</span> <span class="fu">==&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb337-2" title="2">treeHeight (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb337-3" title="3">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> (treeHeight <span class="dt">Empty</span>) (treeHeight <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb337-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> <span class="dv">0</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb337-5" title="5">  <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb337-6" title="6">treeHeight (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
+<a class="sourceLine" id="cb337-7" title="7">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> (treeHeight <span class="dt">Empty</span>) (treeHeight (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))</a>
+<a class="sourceLine" id="cb337-8" title="8">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> <span class="dv">0</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb337-9" title="9">  <span class="fu">==&gt;</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb337-10" title="10">treeHeight (<span class="dt">Node</span> <span class="dv">0</span> (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>)) <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb337-11" title="11">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> (treeHeight (<span class="dt">Node</span> <span class="dv">1</span> <span class="dt">Empty</span> (<span class="dt">Node</span> <span class="dv">2</span> <span class="dt">Empty</span> <span class="dt">Empty</span>))) (treeHeight <span class="dt">Empty</span>)</a>
+<a class="sourceLine" id="cb337-12" title="12">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">max</span> <span class="dv">2</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb337-13" title="13">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>In case you’re familiar with <em>binary search trees</em>, here are the definitions of the lookup and insert opertions for a binary search tree. If you don’t know what I’m talking about, you don’t need to understand this.</p>
-<div class="sourceCode" id="cb338"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb338-1" data-line-number="1">lookup<span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb338-2" data-line-number="2">lookup x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb338-3" data-line-number="3">lookup x (<span class="dt">Node</span> y l r)</a>
-<a class="sourceLine" id="cb338-4" data-line-number="4">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> lookup x l</a>
-<a class="sourceLine" id="cb338-5" data-line-number="5">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> lookup x r</a>
-<a class="sourceLine" id="cb338-6" data-line-number="6">  <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb338-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb338-8" data-line-number="8"><span class="ot">insert ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb338-9" data-line-number="9">insert x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">Node</span> x <span class="dt">Empty</span> <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb338-10" data-line-number="10">insert x (<span class="dt">Node</span> y l r)</a>
-<a class="sourceLine" id="cb338-11" data-line-number="11">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y (insert x l) r</a>
-<a class="sourceLine" id="cb338-12" data-line-number="12">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y l (insert x r)</a>
-<a class="sourceLine" id="cb338-13" data-line-number="13">  <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">Node</span> y l r</a></code></pre></div>
+<div class="sourceCode" id="cb338"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb338-1" title="1"><span class="fu">lookup</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb338-2" title="2"><span class="fu">lookup</span> x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb338-3" title="3"><span class="fu">lookup</span> x (<span class="dt">Node</span> y l r)</a>
+<a class="sourceLine" id="cb338-4" title="4">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> <span class="fu">lookup</span> x l</a>
+<a class="sourceLine" id="cb338-5" title="5">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> <span class="fu">lookup</span> x r</a>
+<a class="sourceLine" id="cb338-6" title="6">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb338-7" title="7"></a>
+<a class="sourceLine" id="cb338-8" title="8"><span class="ot">insert ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb338-9" title="9">insert x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">Node</span> x <span class="dt">Empty</span> <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb338-10" title="10">insert x (<span class="dt">Node</span> y l r)</a>
+<a class="sourceLine" id="cb338-11" title="11">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y (insert x l) r</a>
+<a class="sourceLine" id="cb338-12" title="12">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y l (insert x r)</a>
+<a class="sourceLine" id="cb338-13" title="13">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">Node</span> y l r</a></code></pre></div>
 <h2 id="record-syntax"><span class="header-section-number">5.4</span> Record Syntax</h2>
 <p>If some fields need to be accessed often, it can be convenient to have helper functions for reading those fields. For instance, the type <code>Person</code> might have multiple fields:</p>
-<div class="sourceCode" id="cb339"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb339-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">MkPerson</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span> <span class="dt">String</span> <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
+<div class="sourceCode" id="cb339"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb339-1" title="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">MkPerson</span> <span class="dt">String</span> <span class="dt">Int</span> <span class="dt">String</span> <span class="dt">String</span> <span class="dt">String</span> <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
 <p>A list of persons might look like the following:</p>
-<div class="sourceCode" id="cb340"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb340-1" data-line-number="1"><span class="ot">people ::</span> [<span class="dt">Person</span>]</a>
-<a class="sourceLine" id="cb340-2" data-line-number="2">people <span class="fu">=</span> [ <span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
-<a class="sourceLine" id="cb340-3" data-line-number="3">         , <span class="dt">MkPerson</span> <span class="st">&quot;Maija Meikäläinen&quot;</span> <span class="dv">35</span> <span class="st">&quot;Rovaniemi&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
-<a class="sourceLine" id="cb340-4" data-line-number="4">         , <span class="dt">MkPerson</span> <span class="st">&quot;Mauno Mutikainen&quot;</span> <span class="dv">27</span> <span class="st">&quot;Turku&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Mathematician&quot;</span></a>
-<a class="sourceLine" id="cb340-5" data-line-number="5">         ]</a></code></pre></div>
+<div class="sourceCode" id="cb340"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb340-1" title="1"><span class="ot">people ::</span> [<span class="dt">Person</span>]</a>
+<a class="sourceLine" id="cb340-2" title="2">people <span class="fu">=</span> [ <span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
+<a class="sourceLine" id="cb340-3" title="3">         , <span class="dt">MkPerson</span> <span class="st">&quot;Maija Meikäläinen&quot;</span> <span class="dv">35</span> <span class="st">&quot;Rovaniemi&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
+<a class="sourceLine" id="cb340-4" title="4">         , <span class="dt">MkPerson</span> <span class="st">&quot;Mauno Mutikainen&quot;</span> <span class="dv">27</span> <span class="st">&quot;Turku&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Mathematician&quot;</span></a>
+<a class="sourceLine" id="cb340-5" title="5">         ]</a></code></pre></div>
 <p>Suppose that we need to find all engineers from Finland:</p>
-<div class="sourceCode" id="cb341"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb341-1" data-line-number="1"><span class="ot">query ::</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
-<a class="sourceLine" id="cb341-2" data-line-number="2">query [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb341-3" data-line-number="3">query (<span class="dt">MkPerson</span> name age town state profession)<span class="fu">:</span>xs</a>
-<a class="sourceLine" id="cb341-4" data-line-number="4">  <span class="fu">|</span> state <span class="fu">==</span> <span class="st">&quot;Finland&quot;</span> <span class="fu">&amp;&amp;</span> profession <span class="fu">==</span> <span class="st">&quot;Engineer&quot;</span> <span class="fu">=</span></a>
-<a class="sourceLine" id="cb341-5" data-line-number="5">      (<span class="dt">MkPerson</span> name age town state profession) <span class="fu">:</span> query xs</a>
-<a class="sourceLine" id="cb341-6" data-line-number="6">  <span class="fu">|</span> otherwise <span class="fu">=</span> query xs</a></code></pre></div>
+<div class="sourceCode" id="cb341"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb341-1" title="1"><span class="ot">query ::</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
+<a class="sourceLine" id="cb341-2" title="2">query [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb341-3" title="3">query (<span class="dt">MkPerson</span> name age town state profession)<span class="fu">:</span>xs</a>
+<a class="sourceLine" id="cb341-4" title="4">  <span class="fu">|</span> state <span class="fu">==</span> <span class="st">&quot;Finland&quot;</span> <span class="fu">&amp;&amp;</span> profession <span class="fu">==</span> <span class="st">&quot;Engineer&quot;</span> <span class="fu">=</span></a>
+<a class="sourceLine" id="cb341-5" title="5">      (<span class="dt">MkPerson</span> name age town state profession) <span class="fu">:</span> query xs</a>
+<a class="sourceLine" id="cb341-6" title="6">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> query xs</a></code></pre></div>
 <p>Thus,</p>
-<div class="sourceCode" id="cb342"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb342-1" data-line-number="1">query people <span class="fu">==&gt;</span> [<span class="dt">MkPerson</span> <span class="st">&quot;Maija Meikäläinen&quot;</span> <span class="dv">35</span> <span class="st">&quot;Rovaniemi&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Engineer&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb342"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb342-1" title="1">query people <span class="fu">==&gt;</span> [<span class="dt">MkPerson</span> <span class="st">&quot;Maija Meikäläinen&quot;</span> <span class="dv">35</span> <span class="st">&quot;Rovaniemi&quot;</span> <span class="st">&quot;Finland&quot;</span> <span class="st">&quot;Engineer&quot;</span>]</a></code></pre></div>
 <p>Note that the types of the fields give little information on what is the intended content in those fields. We need to remember in all places in the code that <code>town</code> goes before <code>state</code> and not vice versa.</p>
 <p>Haskell has a feature called <em>record syntax</em> that is helpful in these kinds of cases. The datatype <code>Person</code> can be defined as a record:</p>
-<div class="sourceCode" id="cb343"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb343-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">MkPerson</span> {<span class="ot"> name ::</span> <span class="dt">String</span>,<span class="ot"> age ::</span> <span class="dt">Int</span>,<span class="ot"> town ::</span> <span class="dt">String</span>,<span class="ot"> state ::</span> <span class="dt">String</span>,<span class="ot"> profession ::</span> <span class="dt">String</span>}</a>
-<a class="sourceLine" id="cb343-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
+<div class="sourceCode" id="cb343"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb343-1" title="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">MkPerson</span> {<span class="ot"> name ::</span> <span class="dt">String</span>,<span class="ot"> age ::</span> <span class="dt">Int</span>,<span class="ot"> town ::</span> <span class="dt">String</span>,<span class="ot"> state ::</span> <span class="dt">String</span>,<span class="ot"> profession ::</span> <span class="dt">String</span>}</a>
+<a class="sourceLine" id="cb343-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
 <p>We can still define values of <code>Person</code> normally, but the <code>Show</code> instance prints the field names for us:</p>
-<div class="sourceCode" id="cb344"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb344-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
-<a class="sourceLine" id="cb344-2" data-line-number="2"><span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>}</a></code></pre></div>
+<div class="sourceCode" id="cb344"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb344-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span></a>
+<a class="sourceLine" id="cb344-2" title="2"><span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>}</a></code></pre></div>
 <p>However, we can also define values using record syntax. Note how the fields don’t need to be in any specific order now that they have names.</p>
-<div class="sourceCode" id="cb345"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb345-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>}</a>
-<a class="sourceLine" id="cb345-2" data-line-number="2"><span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>}</a></code></pre></div>
+<div class="sourceCode" id="cb345"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb345-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>}</a>
+<a class="sourceLine" id="cb345-2" title="2"><span class="dt">MkPerson</span> {name <span class="fu">=</span> <span class="st">&quot;Jane Doe&quot;</span>, age <span class="fu">=</span> <span class="dv">21</span>, town <span class="fu">=</span> <span class="st">&quot;Houston&quot;</span>, state <span class="fu">=</span> <span class="st">&quot;Texas&quot;</span>, profession <span class="fu">=</span> <span class="st">&quot;Engineer&quot;</span>}</a></code></pre></div>
 <p>Most importantly, We get <em>accessor functions</em> for the fields for free:</p>
-<div class="sourceCode" id="cb346"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb346-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t profession</a>
-<a class="sourceLine" id="cb346-2" data-line-number="2"><span class="ot">profession ::</span> <span class="dt">Person</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb346-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> profession (<span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span>)</a>
-<a class="sourceLine" id="cb346-4" data-line-number="4"><span class="st">&quot;Engineer&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb346"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb346-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t profession</a>
+<a class="sourceLine" id="cb346-2" title="2"><span class="ot">profession ::</span> <span class="dt">Person</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb346-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> profession (<span class="dt">MkPerson</span> <span class="st">&quot;Jane Doe&quot;</span> <span class="dv">21</span> <span class="st">&quot;Houston&quot;</span> <span class="st">&quot;Texas&quot;</span> <span class="st">&quot;Engineer&quot;</span>)</a>
+<a class="sourceLine" id="cb346-4" title="4"><span class="st">&quot;Engineer&quot;</span></a></code></pre></div>
 <p>We can now rewrite the query function using these accessor functions:</p>
-<div class="sourceCode" id="cb347"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb347-1" data-line-number="1"><span class="ot">query ::</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
-<a class="sourceLine" id="cb347-2" data-line-number="2">query []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb347-3" data-line-number="3">query (x<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb347-4" data-line-number="4">  <span class="fu">|</span> state x <span class="fu">==</span> <span class="st">&quot;Finland&quot;</span> <span class="fu">&amp;&amp;</span> profession x <span class="fu">==</span> <span class="st">&quot;Engineer&quot;</span> <span class="fu">=</span></a>
-<a class="sourceLine" id="cb347-5" data-line-number="5">      x <span class="fu">:</span> query xs</a>
-<a class="sourceLine" id="cb347-6" data-line-number="6">  <span class="fu">|</span> otherwise <span class="fu">=</span> query xs</a></code></pre></div>
+<div class="sourceCode" id="cb347"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb347-1" title="1"><span class="ot">query ::</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
+<a class="sourceLine" id="cb347-2" title="2">query []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb347-3" title="3">query (x<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb347-4" title="4">  <span class="fu">|</span> state x <span class="fu">==</span> <span class="st">&quot;Finland&quot;</span> <span class="fu">&amp;&amp;</span> profession x <span class="fu">==</span> <span class="st">&quot;Engineer&quot;</span> <span class="fu">=</span></a>
+<a class="sourceLine" id="cb347-5" title="5">      x <span class="fu">:</span> query xs</a>
+<a class="sourceLine" id="cb347-6" title="6">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> query xs</a></code></pre></div>
 <p>You’ll probably agree that the code looks more pleasant now.</p>
 <h2 id="algebraic-datatypes-summary"><span class="header-section-number">5.5</span> Algebraic Datatypes: Summary</h2>
 <ul>
 <li>Types are defined like this</li>
 </ul>
-<div class="sourceCode" id="cb348"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb348-1" data-line-number="1"><span class="kw">data</span> <span class="dt">TypeName</span> <span class="fu">=</span> <span class="dt">ConstructorName</span> <span class="dt">FieldType</span> <span class="dt">FieldType2</span> <span class="fu">|</span> <span class="dt">AnotherConstructor</span> <span class="dt">FieldType3</span> <span class="fu">|</span> <span class="dt">OneMoreCons</span></a></code></pre></div>
+<div class="sourceCode" id="cb348"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb348-1" title="1"><span class="kw">data</span> <span class="dt">TypeName</span> <span class="fu">=</span> <span class="dt">ConstructorName</span> <span class="dt">FieldType</span> <span class="dt">FieldType2</span> <span class="fu">|</span> <span class="dt">AnotherConstructor</span> <span class="dt">FieldType3</span> <span class="fu">|</span> <span class="dt">OneMoreCons</span></a></code></pre></div>
 <ul>
 <li>… or like this if we’re using type variables</li>
 </ul>
-<div class="sourceCode" id="cb349"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb349-1" data-line-number="1"><span class="kw">data</span> <span class="dt">TypeName</span> variable <span class="fu">=</span> <span class="dt">Cons1</span> variable <span class="dt">Type1</span> <span class="fu">|</span> <span class="dt">Cons2</span> <span class="dt">Type2</span> variable</a></code></pre></div>
+<div class="sourceCode" id="cb349"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb349-1" title="1"><span class="kw">data</span> <span class="dt">TypeName</span> variable <span class="fu">=</span> <span class="dt">Cons1</span> variable <span class="dt">Type1</span> <span class="fu">|</span> <span class="dt">Cons2</span> <span class="dt">Type2</span> variable</a></code></pre></div>
 <ul>
 <li>You can have one or more constructors</li>
 <li>Each constructor can have zero or more fields</li>
 <li>Constructors start with upper case, type variables with lower case</li>
 <li>Values are handled with pattern matching:</li>
 </ul>
-<div class="sourceCode" id="cb350"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb350-1" data-line-number="1">foo (<span class="dt">ConstructorName</span> a b) <span class="fu">=</span> a<span class="fu">+</span>b</a>
-<a class="sourceLine" id="cb350-2" data-line-number="2">foo (<span class="dt">AnotherConstructor</span> _) <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb350-3" data-line-number="3">foo <span class="dt">OneMoreCons</span> <span class="fu">=</span> <span class="dv">7</span></a></code></pre></div>
+<div class="sourceCode" id="cb350"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb350-1" title="1">foo (<span class="dt">ConstructorName</span> a b) <span class="fu">=</span> a<span class="fu">+</span>b</a>
+<a class="sourceLine" id="cb350-2" title="2">foo (<span class="dt">AnotherConstructor</span> _) <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb350-3" title="3">foo <span class="dt">OneMoreCons</span> <span class="fu">=</span> <span class="dv">7</span></a></code></pre></div>
 <ul>
 <li>Constructors are just functions:</li>
 </ul>
-<div class="sourceCode" id="cb351"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb351-1" data-line-number="1"><span class="dt">ConstructorName</span><span class="ot"> ::</span> <span class="dt">FieldType</span> <span class="ot">-&gt;</span> <span class="dt">FieldType2</span> <span class="ot">-&gt;</span> <span class="dt">TypeName</span></a>
-<a class="sourceLine" id="cb351-2" data-line-number="2"><span class="dt">Cons1</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> <span class="dt">Type1</span> <span class="ot">-&gt;</span> <span class="dt">TypeName</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb351"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb351-1" title="1"><span class="dt">ConstructorName</span><span class="ot"> ::</span> <span class="dt">FieldType</span> <span class="ot">-&gt;</span> <span class="dt">FieldType2</span> <span class="ot">-&gt;</span> <span class="dt">TypeName</span></a>
+<a class="sourceLine" id="cb351-2" title="2"><span class="dt">Cons1</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> <span class="dt">Type1</span> <span class="ot">-&gt;</span> <span class="dt">TypeName</span> a</a></code></pre></div>
 <ul>
 <li>You can also define datatypes using record syntax:</li>
 </ul>
-<div class="sourceCode" id="cb352"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb352-1" data-line-number="1"><span class="kw">data</span> <span class="dt">TypeName</span> <span class="fu">=</span> <span class="dt">Constructor</span> {<span class="ot"> field1 ::</span> <span class="dt">Field1Type</span>,<span class="ot"> field2 ::</span> <span class="dt">Field2Type</span> }</a></code></pre></div>
+<div class="sourceCode" id="cb352"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb352-1" title="1"><span class="kw">data</span> <span class="dt">TypeName</span> <span class="fu">=</span> <span class="dt">Constructor</span> {<span class="ot"> field1 ::</span> <span class="dt">Field1Type</span>,<span class="ot"> field2 ::</span> <span class="dt">Field2Type</span> }</a></code></pre></div>
 <p>This gives you accessor functions like <code>field1 :: TypeName -&gt; Field1Type</code> for free.</p>
 <h2 id="sidenote-other-ways-of-defining-types"><span class="header-section-number">5.6</span> Sidenote: Other Ways of Defining Types</h2>
 <p>In addition to the <code>data</code> keyword, there are two additional ways of defining types in Haskell.</p>
 <p>The <code>newtype</code> keyword works like <code>data</code>, but you can only have a single constructor with a single field. It’s sometimes wise to use <code>newtype</code> for performance resons, but we’ll get back to those in part 2.</p>
 <p>The <code>type</code> keyword introduces a <em>type alias</em>. Type aliases don’t affect type checking, they just offer a shorthand for writing types. For example the familiar <code>String</code> type is an alias for <code>[Char]</code>:</p>
-<div class="sourceCode" id="cb353"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb353-1" data-line-number="1"><span class="kw">type</span> <span class="dt">String</span> <span class="fu">=</span> [<span class="dt">Char</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb353"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb353-1" title="1"><span class="kw">type</span> <span class="dt">String</span> <span class="fu">=</span> [<span class="dt">Char</span>]</a></code></pre></div>
 <p>This means that whenever the compiler reads <code>String</code>, it just immediately replaces it with <code>[Char]</code>. Type aliases seem useful, but they can easily make reading type errors harder.</p>
 <h2 id="how-do-algebraic-datatypes-work"><span class="header-section-number">5.7</span> How Do Algebraic Datatypes Work?</h2>
 <p>Remember how lists were represented in memory as linked lists? Let’s look in more detail at what algebraic datatypes look like in memory.</p>
 <p>Haskell data forms <em>directed graphs</em> in memory. Every constructor is a node, every field is an edge. Names (of variables) are pointers into this graph. Different names can <em>share</em> parts of the structure. Here’s an example with lists. Note how the last two elements of <code>x</code> are shared with <code>y</code> and <code>z</code>.</p>
-<div class="sourceCode" id="cb354"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb354-1" data-line-number="1"><span class="kw">let</span> x <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb354-2" data-line-number="2">    y <span class="fu">=</span> drop <span class="dv">2</span> x</a>
-<a class="sourceLine" id="cb354-3" data-line-number="3">    z <span class="fu">=</span> <span class="dv">5</span><span class="fu">:</span>y</a></code></pre></div>
+<div class="sourceCode" id="cb354"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb354-1" title="1"><span class="kw">let</span> x <span class="fu">=</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb354-2" title="2">    y <span class="fu">=</span> <span class="fu">drop</span> <span class="dv">2</span> x</a>
+<a class="sourceLine" id="cb354-3" title="3">    z <span class="fu">=</span> <span class="dv">5</span><span class="fu">:</span>y</a></code></pre></div>
 <p><img src="img/DAG1.svg" /></p>
 <!--
 ```haskell
@@ -3100,8 +3098,8 @@ let x = [1,2,3,4]        (1:) -> (2:) -> (3:) -> (4:) -> []
 -->
 <p>What happens when you make a new version of a datastructure is called <em>path copying</em>. Since Haskell data is immutable, the changed parts of the datastructure get copied, while the unchanged parts can be shared between the old and new versions.</p>
 <p>Consider the definition of <code>++</code>:</p>
-<div class="sourceCode" id="cb355"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb355-1" data-line-number="1">[]     <span class="fu">++</span> ys <span class="fu">=</span> ys</a>
-<a class="sourceLine" id="cb355-2" data-line-number="2">(x<span class="fu">:</span>xs) <span class="fu">++</span> ys <span class="fu">=</span> x<span class="fu">:</span>(xs <span class="fu">++</span> ys)</a></code></pre></div>
+<div class="sourceCode" id="cb355"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb355-1" title="1">[]     <span class="fu">++</span> ys <span class="fu">=</span> ys</a>
+<a class="sourceLine" id="cb355-2" title="2">(x<span class="fu">:</span>xs) <span class="fu">++</span> ys <span class="fu">=</span> x<span class="fu">:</span>(xs <span class="fu">++</span> ys)</a></code></pre></div>
 <p>We are making a copy of the first argument while we walk it. For every <code>:</code> constructor in the first input list, we are creating a new <code>:</code> constructor in the output list. The second argument can be shared. It is not used at all in the recursion. Visually:</p>
 <p><img src="img/DAG2.svg" /></p>
 <!--
@@ -3116,12 +3114,12 @@ xs ++ ys -> (1:) -> (2:) -> (3:) --+
 -->
 <p>One more way to think about it is this: we want to change the <code>tail</code> pointer of the list element <code>(3:)</code>. That means we need to make a new <code>(3:)</code>. However the <code>(2:)</code> points to the <code>(3:)</code> so we need a new copy of the <code>(2:)</code> as well. Likewise for <code>(1:)</code>.</p>
 <p>The graphs that we get when working with lists are fairly simple. As a more involved example, here is what happens in memory when we run the binary tree insertion example from earlier in this lecture.</p>
-<div class="sourceCode" id="cb356"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb356-1" data-line-number="1"><span class="ot">insert ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb356-2" data-line-number="2">insert x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">Node</span> x <span class="dt">Empty</span> <span class="dt">Empty</span></a>
-<a class="sourceLine" id="cb356-3" data-line-number="3">insert x (<span class="dt">Node</span> y l r)</a>
-<a class="sourceLine" id="cb356-4" data-line-number="4">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y (insert x l) r</a>
-<a class="sourceLine" id="cb356-5" data-line-number="5">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y l (insert x r)</a>
-<a class="sourceLine" id="cb356-6" data-line-number="6">  <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">Node</span> y l r</a></code></pre></div>
+<div class="sourceCode" id="cb356"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb356-1" title="1"><span class="ot">insert ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Tree</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb356-2" title="2">insert x <span class="dt">Empty</span> <span class="fu">=</span> <span class="dt">Node</span> x <span class="dt">Empty</span> <span class="dt">Empty</span></a>
+<a class="sourceLine" id="cb356-3" title="3">insert x (<span class="dt">Node</span> y l r)</a>
+<a class="sourceLine" id="cb356-4" title="4">  <span class="fu">|</span> x <span class="fu">&lt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y (insert x l) r</a>
+<a class="sourceLine" id="cb356-5" title="5">  <span class="fu">|</span> x <span class="fu">&gt;</span> y <span class="fu">=</span> <span class="dt">Node</span> y l (insert x r)</a>
+<a class="sourceLine" id="cb356-6" title="6">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">Node</span> y l r</a></code></pre></div>
 <p><img src="img/DAG3.svg" /> <!--
 ```haskell
             t              insert 6 t
@@ -3200,56 +3198,56 @@ Because <code>Nothing</code> is a constructor.
 <h1 id="lecture-6-working-class-hero"><span class="header-section-number">6</span> Lecture 6: Working Class Hero</h1>
 <p>We’ve seen class constraints like <code>Eq a =&gt;</code> in types. We know how to use existing classes with existing types. But how do we use existing classes with our own types? How can we define our own classes?</p>
 <p>Here’s how to make your own type a member of the <code>Eq</code> class:</p>
-<div class="sourceCode" id="cb357"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb357-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Black</span> <span class="fu">|</span> <span class="dt">White</span></a>
-<a class="sourceLine" id="cb357-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb357-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">Color</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb357-4" data-line-number="4">  <span class="dt">Black</span> <span class="fu">==</span> <span class="dt">Black</span>  <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb357-5" data-line-number="5">  <span class="dt">White</span> <span class="fu">==</span> <span class="dt">White</span>  <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb357-6" data-line-number="6">  _     <span class="fu">==</span> _      <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb357"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb357-1" title="1"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Black</span> <span class="fu">|</span> <span class="dt">White</span></a>
+<a class="sourceLine" id="cb357-2" title="2"></a>
+<a class="sourceLine" id="cb357-3" title="3"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">Color</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb357-4" title="4">  <span class="dt">Black</span> <span class="fu">==</span> <span class="dt">Black</span>  <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb357-5" title="5">  <span class="dt">White</span> <span class="fu">==</span> <span class="dt">White</span>  <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb357-6" title="6">  _     <span class="fu">==</span> _      <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <p>A class instance is an <code>instance</code> block that contains definitions for the functions in that class. Here we define how <code>==</code> works on <code>Color</code>.</p>
 <h2 id="syntax-of-classes-and-instances"><span class="header-section-number">6.1</span> Syntax of Classes and Instances</h2>
 <p>A type class is defined using <code>class</code> syntax. The functions in the class are given types. Here’s a class <code>Size</code> that contains one function, <code>size</code>:</p>
-<div class="sourceCode" id="cb358"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb358-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb358-2" data-line-number="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb358"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb358-1" title="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb358-2" title="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
 <p>Instances of a class are defined with <code>instance</code> syntax we’ve just seen. Here is how we make <code>Int</code> and <code>[a]</code> members of the <code>Size</code> class:</p>
-<div class="sourceCode" id="cb359"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb359-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Size</span> <span class="dt">Int</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb359-2" data-line-number="2">  size x <span class="fu">=</span> abs x</a>
-<a class="sourceLine" id="cb359-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb359-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Size</span> [a] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb359-5" data-line-number="5">  size xs <span class="fu">=</span> length xs</a></code></pre></div>
+<div class="sourceCode" id="cb359"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb359-1" title="1"><span class="kw">instance</span> <span class="dt">Size</span> <span class="dt">Int</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb359-2" title="2">  size x <span class="fu">=</span> <span class="fu">abs</span> x</a>
+<a class="sourceLine" id="cb359-3" title="3"></a>
+<a class="sourceLine" id="cb359-4" title="4"><span class="kw">instance</span> <span class="dt">Size</span> [a] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb359-5" title="5">  size xs <span class="fu">=</span> <span class="fu">length</span> xs</a></code></pre></div>
 <p>Our class <code>Size</code> behaves just like existing type classes. We can use <code>size</code> anywhere where a function can be used, and Haskell can infer types with <code>Size</code> constraints for us:</p>
-<div class="sourceCode" id="cb360"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb360-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t size</a>
-<a class="sourceLine" id="cb360-2" data-line-number="2"><span class="ot">size ::</span> <span class="dt">Size</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb360-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> size [<span class="dt">True</span>,<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb360-4" data-line-number="4"><span class="dv">2</span></a>
-<a class="sourceLine" id="cb360-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> sizeBoth a b <span class="fu">=</span> [size a, size b]</a>
-<a class="sourceLine" id="cb360-6" data-line-number="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t sizeBoth</a>
-<a class="sourceLine" id="cb360-7" data-line-number="7"><span class="ot">sizeBoth ::</span> (<span class="dt">Size</span> a1, <span class="dt">Size</span> a2) <span class="ot">=&gt;</span> a1 <span class="ot">-&gt;</span> a2 <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb360"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb360-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t size</a>
+<a class="sourceLine" id="cb360-2" title="2"><span class="ot">size ::</span> <span class="dt">Size</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb360-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> size [<span class="dt">True</span>,<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb360-4" title="4"><span class="dv">2</span></a>
+<a class="sourceLine" id="cb360-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> sizeBoth a b <span class="fu">=</span> [size a, size b]</a>
+<a class="sourceLine" id="cb360-6" title="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t sizeBoth</a>
+<a class="sourceLine" id="cb360-7" title="7"><span class="ot">sizeBoth ::</span> (<span class="dt">Size</span> a1, <span class="dt">Size</span> a2) <span class="ot">=&gt;</span> a1 <span class="ot">-&gt;</span> a2 <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a></code></pre></div>
 <p>A class can contain multiple functions, and even constants. Here we define a new version of the <code>Size</code> class with more content.</p>
-<div class="sourceCode" id="cb361"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb361-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb361-2" data-line-number="2"><span class="ot">  empty ::</span> a</a>
-<a class="sourceLine" id="cb361-3" data-line-number="3"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb361-4" data-line-number="4"><span class="ot">  sameSize ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb361-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb361-6" data-line-number="6"><span class="kw">instance</span> <span class="dt">Size</span> (<span class="dt">Maybe</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb361-7" data-line-number="7">  empty <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb361-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb361-9" data-line-number="9">  size <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb361-10" data-line-number="10">  size (<span class="dt">Just</span> a) <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb361-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb361-12" data-line-number="12">  sameSize x y <span class="fu">=</span> size x <span class="fu">==</span> size y</a>
-<a class="sourceLine" id="cb361-13" data-line-number="13"></a>
-<a class="sourceLine" id="cb361-14" data-line-number="14"><span class="kw">instance</span> <span class="dt">Size</span> [a] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb361-15" data-line-number="15">  empty <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb361-16" data-line-number="16">  size xs <span class="fu">=</span> length xs</a>
-<a class="sourceLine" id="cb361-17" data-line-number="17">  sameSize x y <span class="fu">=</span> size x <span class="fu">==</span> size y</a></code></pre></div>
+<div class="sourceCode" id="cb361"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb361-1" title="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb361-2" title="2"><span class="ot">  empty ::</span> a</a>
+<a class="sourceLine" id="cb361-3" title="3"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb361-4" title="4"><span class="ot">  sameSize ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb361-5" title="5"></a>
+<a class="sourceLine" id="cb361-6" title="6"><span class="kw">instance</span> <span class="dt">Size</span> (<span class="dt">Maybe</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb361-7" title="7">  empty <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb361-8" title="8"></a>
+<a class="sourceLine" id="cb361-9" title="9">  size <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb361-10" title="10">  size (<span class="dt">Just</span> a) <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb361-11" title="11"></a>
+<a class="sourceLine" id="cb361-12" title="12">  sameSize x y <span class="fu">=</span> size x <span class="fu">==</span> size y</a>
+<a class="sourceLine" id="cb361-13" title="13"></a>
+<a class="sourceLine" id="cb361-14" title="14"><span class="kw">instance</span> <span class="dt">Size</span> [a] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb361-15" title="15">  empty <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb361-16" title="16">  size xs <span class="fu">=</span> <span class="fu">length</span> xs</a>
+<a class="sourceLine" id="cb361-17" title="17">  sameSize x y <span class="fu">=</span> size x <span class="fu">==</span> size y</a></code></pre></div>
 <h2 id="sidenote-restrictions-on-instances"><span class="header-section-number">6.2</span> Sidenote: Restrictions on Instances</h2>
 <p>The Haskell 2010 allows only a very specific type of class instance. Let’s look at some instances that aren’t allowed. The examples use the <code>Size</code> class:</p>
-<div class="sourceCode" id="cb362"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb362-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb362-2" data-line-number="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb362"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb362-1" title="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb362-2" title="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a></code></pre></div>
 <p>We saw a <code>Size [a]</code> instance above. Why not define an instance just for lists of booleans?</p>
-<div class="sourceCode" id="cb363"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb363-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Size</span> [<span class="dt">Bool</span>] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb363-2" data-line-number="2">  size bs <span class="fu">=</span> length (filter id bs)   <span class="co">-- count Trues</span></a></code></pre></div>
+<div class="sourceCode" id="cb363"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb363-1" title="1"><span class="kw">instance</span> <span class="dt">Size</span> [<span class="dt">Bool</span>] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb363-2" title="2">  size bs <span class="fu">=</span> <span class="fu">length</span> (<span class="fu">filter</span> <span class="fu">id</span> bs)   <span class="co">-- count Trues</span></a></code></pre></div>
 <pre class="haskel"><code>error:
     • Illegal instance declaration for ‘Size [Bool]’
         (All instance types must be of the form (T a1 ... an)
@@ -3267,189 +3265,189 @@ Because <code>Nothing</code> is a constructor.
 <p>The GHC Haskell implementation has many extensions to the type class system – we’ll get back to some of them in part 2 of this course.</p>
 <h2 id="default-implementations"><span class="header-section-number">6.3</span> Default Implementations</h2>
 <p>Did you notice how in the previous example we gave <code>sameSize</code> the same definition in both instances? This is a very common occurrence, and it’s why Haskell classes can have <em>default implementations</em>. As a first example, here’s an <code>Example</code> type class for giving example values of types.</p>
-<div class="sourceCode" id="cb365"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb365-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Example</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb365-2" data-line-number="2"><span class="ot">  example ::</span> a           <span class="co">-- the main example for the type `a`</span></a>
-<a class="sourceLine" id="cb365-3" data-line-number="3"><span class="ot">  examples ::</span> [a]        <span class="co">-- a short list of examples</span></a>
-<a class="sourceLine" id="cb365-4" data-line-number="4">  examples <span class="fu">=</span> [example]   <span class="co">-- ...defaulting to just the main example</span></a>
-<a class="sourceLine" id="cb365-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb365-6" data-line-number="6"><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Int</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb365-7" data-line-number="7">  example <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb365-8" data-line-number="8">  examples <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb365-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb365-10" data-line-number="10"><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Bool</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb365-11" data-line-number="11">  example <span class="fu">=</span> <span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb365"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb365-1" title="1"><span class="kw">class</span> <span class="dt">Example</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb365-2" title="2"><span class="ot">  example ::</span> a           <span class="co">-- the main example for the type `a`</span></a>
+<a class="sourceLine" id="cb365-3" title="3"><span class="ot">  examples ::</span> [a]        <span class="co">-- a short list of examples</span></a>
+<a class="sourceLine" id="cb365-4" title="4">  examples <span class="fu">=</span> [example]   <span class="co">-- ...defaulting to just the main example</span></a>
+<a class="sourceLine" id="cb365-5" title="5"></a>
+<a class="sourceLine" id="cb365-6" title="6"><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Int</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb365-7" title="7">  example <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb365-8" title="8">  examples <span class="fu">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb365-9" title="9"></a>
+<a class="sourceLine" id="cb365-10" title="10"><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Bool</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb365-11" title="11">  example <span class="fu">=</span> <span class="dt">True</span></a></code></pre></div>
 <p>Here’s how <code>Example</code> works. Note how the default implementation of <code>examples</code> got used in the <code>Bool</code> case but not in the <code>Int</code> case. Also note the need for explicit type signatures to tell GHCi which instance we’re interested in. Without them, we would get an “Ambiguous type variable” error.</p>
-<div class="sourceCode" id="cb366"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb366-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> example ::</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb366-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb366-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> example ::</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb366-4" data-line-number="4"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb366-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Bool</span>]</a>
-<a class="sourceLine" id="cb366-6" data-line-number="6">[<span class="dt">True</span>]</a>
-<a class="sourceLine" id="cb366-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb366-8" data-line-number="8">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb366"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb366-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> example ::</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb366-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb366-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> example ::</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb366-4" title="4"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb366-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Bool</span>]</a>
+<a class="sourceLine" id="cb366-6" title="6">[<span class="dt">True</span>]</a>
+<a class="sourceLine" id="cb366-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb366-8" title="8">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
 <p>The standard type classes use lots of default implementations to make implementing the classes easy. Here is the standard definitions for <code>Eq</code> (formatted for readability).</p>
-<div class="sourceCode" id="cb367"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb367-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb367-2" data-line-number="2"><span class="ot">  (==) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb367-3" data-line-number="3">  x <span class="fu">==</span> y  <span class="fu">=</span> not (x <span class="fu">/=</span> y)</a>
-<a class="sourceLine" id="cb367-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb367-5" data-line-number="5"><span class="ot">  (/=) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb367-6" data-line-number="6">  x <span class="fu">/=</span> y  <span class="fu">=</span> not (x <span class="fu">==</span> y)</a></code></pre></div>
+<div class="sourceCode" id="cb367"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb367-1" title="1"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb367-2" title="2"><span class="ot">  (==) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb367-3" title="3">  x <span class="fu">==</span> y  <span class="fu">=</span> <span class="fu">not</span> (x <span class="fu">/=</span> y)</a>
+<a class="sourceLine" id="cb367-4" title="4"></a>
+<a class="sourceLine" id="cb367-5" title="5"><span class="ot">  (/=) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb367-6" title="6">  x <span class="fu">/=</span> y  <span class="fu">=</span> <span class="fu">not</span> (x <span class="fu">==</span> y)</a></code></pre></div>
 <p>Note how both operations have a default implementation in terms of the other. This means we could define an <code>Eq</code> instance with no content at all, but the resulting functions would just recurse forever. In practice, we want to define at least one of <code>==</code> and <code>/=</code>.</p>
 <p>When there are lots of default implementations, it can be hard to know which functions you need to implement yourself. For this reason class documentation usually mentions the <em>minimal complete definition</em>. For <code>Eq</code>, <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Prelude.html#t:Eq">the docs say</a> “Minimal complete definition: either == or /=.”</p>
 <p>Let’s look at <code>Ord</code> next. <code>Ord</code> has 7 operations, all with default implementations in terms of each other. By the way, note the quirky way of defining multiple type signatures at once. It’s okay, it’s a feature of Haskell, this is how <code>Ord</code> is defined in <a href="https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1270006.3">the standard</a>. (We’ll get back to what the <code>(Eq a) =&gt;</code> part means soon.)</p>
-<div class="sourceCode" id="cb368"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb368-1" data-line-number="1"><span class="kw">class</span>  (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> <span class="dt">Ord</span> a  <span class="kw">where</span></a>
-<a class="sourceLine" id="cb368-2" data-line-number="2"><span class="ot">  compare              ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
-<a class="sourceLine" id="cb368-3" data-line-number="3">  (<span class="fu">&lt;</span>), (<span class="fu">&lt;=</span>), (<span class="fu">&gt;=</span>),<span class="ot"> (&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb368-4" data-line-number="4">  max,<span class="ot"> min             ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb368-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb368-6" data-line-number="6">  compare x y <span class="fu">|</span> x <span class="fu">==</span> y    <span class="fu">=</span> <span class="dt">EQ</span></a>
-<a class="sourceLine" id="cb368-7" data-line-number="7">              <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span> <span class="dt">LT</span></a>
-<a class="sourceLine" id="cb368-8" data-line-number="8">              <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">GT</span></a>
-<a class="sourceLine" id="cb368-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb368-10" data-line-number="10">  x <span class="fu">&lt;=</span> y  <span class="fu">=</span> compare x y <span class="fu">/=</span> <span class="dt">GT</span></a>
-<a class="sourceLine" id="cb368-11" data-line-number="11">  x <span class="fu">&lt;</span>  y  <span class="fu">=</span> compare x y <span class="fu">==</span> <span class="dt">LT</span></a>
-<a class="sourceLine" id="cb368-12" data-line-number="12">  x <span class="fu">&gt;=</span> y  <span class="fu">=</span> compare x y <span class="fu">/=</span> <span class="dt">LT</span></a>
-<a class="sourceLine" id="cb368-13" data-line-number="13">  x <span class="fu">&gt;</span>  y  <span class="fu">=</span> compare x y <span class="fu">==</span> <span class="dt">GT</span></a>
-<a class="sourceLine" id="cb368-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb368-15" data-line-number="15">  max x y <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span>  y</a>
-<a class="sourceLine" id="cb368-16" data-line-number="16">          <span class="fu">|</span> otherwise <span class="fu">=</span>  x</a>
-<a class="sourceLine" id="cb368-17" data-line-number="17">  min x y <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span>  x</a>
-<a class="sourceLine" id="cb368-18" data-line-number="18">          <span class="fu">|</span> otherwise <span class="fu">=</span>  y</a></code></pre></div>
+<div class="sourceCode" id="cb368"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb368-1" title="1"><span class="kw">class</span>  (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> <span class="dt">Ord</span> a  <span class="kw">where</span></a>
+<a class="sourceLine" id="cb368-2" title="2"><span class="ot">  compare              ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></a>
+<a class="sourceLine" id="cb368-3" title="3">  (<span class="fu">&lt;</span>), (<span class="fu">&lt;=</span>), (<span class="fu">&gt;=</span>),<span class="ot"> (&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb368-4" title="4">  <span class="fu">max</span>,<span class="ot"> min             ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb368-5" title="5"></a>
+<a class="sourceLine" id="cb368-6" title="6">  <span class="fu">compare</span> x y <span class="fu">|</span> x <span class="fu">==</span> y    <span class="fu">=</span> <span class="dt">EQ</span></a>
+<a class="sourceLine" id="cb368-7" title="7">              <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span> <span class="dt">LT</span></a>
+<a class="sourceLine" id="cb368-8" title="8">              <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">GT</span></a>
+<a class="sourceLine" id="cb368-9" title="9"></a>
+<a class="sourceLine" id="cb368-10" title="10">  x <span class="fu">&lt;=</span> y  <span class="fu">=</span> <span class="fu">compare</span> x y <span class="fu">/=</span> <span class="dt">GT</span></a>
+<a class="sourceLine" id="cb368-11" title="11">  x <span class="fu">&lt;</span>  y  <span class="fu">=</span> <span class="fu">compare</span> x y <span class="fu">==</span> <span class="dt">LT</span></a>
+<a class="sourceLine" id="cb368-12" title="12">  x <span class="fu">&gt;=</span> y  <span class="fu">=</span> <span class="fu">compare</span> x y <span class="fu">/=</span> <span class="dt">LT</span></a>
+<a class="sourceLine" id="cb368-13" title="13">  x <span class="fu">&gt;</span>  y  <span class="fu">=</span> <span class="fu">compare</span> x y <span class="fu">==</span> <span class="dt">GT</span></a>
+<a class="sourceLine" id="cb368-14" title="14"></a>
+<a class="sourceLine" id="cb368-15" title="15">  <span class="fu">max</span> x y <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span>  y</a>
+<a class="sourceLine" id="cb368-16" title="16">          <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span>  x</a>
+<a class="sourceLine" id="cb368-17" title="17">  <span class="fu">min</span> x y <span class="fu">|</span> x <span class="fu">&lt;=</span> y    <span class="fu">=</span>  x</a>
+<a class="sourceLine" id="cb368-18" title="18">          <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span>  y</a></code></pre></div>
 <p>With this definition it’s really hard to know what the minimal complete definition is. Luckily the <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Prelude.html#t:Ord">docs tell us</a> “Minimal complete definition: either compare or &lt;=.”</p>
 <p>As a final word on default implementations, if there is never a need to override the default definition, the function can be moved out of the class for simplicity. Consider a class like <code>Combine</code> below:</p>
-<div class="sourceCode" id="cb369"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb369-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb369-2" data-line-number="2"><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb369-3" data-line-number="3"><span class="ot">  combine3 ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb369-4" data-line-number="4">  combine3 x y z <span class="fu">=</span> combine x (combine y z)</a></code></pre></div>
+<div class="sourceCode" id="cb369"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb369-1" title="1"><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb369-2" title="2"><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb369-3" title="3"><span class="ot">  combine3 ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb369-4" title="4">  combine3 x y z <span class="fu">=</span> combine x (combine y z)</a></code></pre></div>
 <p>It’s hard to think of a case where <code>combine3</code> would be given any other definition, so why not move it out of the class:</p>
-<div class="sourceCode" id="cb370"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb370-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb370-2" data-line-number="2"><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb370-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb370-4" data-line-number="4"><span class="ot">combine3 ::</span> <span class="dt">Combine</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb370-5" data-line-number="5">combine3 x y z <span class="fu">=</span> combine x (combine y z)</a></code></pre></div>
+<div class="sourceCode" id="cb370"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb370-1" title="1"><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb370-2" title="2"><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb370-3" title="3"></a>
+<a class="sourceLine" id="cb370-4" title="4"><span class="ot">combine3 ::</span> <span class="dt">Combine</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb370-5" title="5">combine3 x y z <span class="fu">=</span> combine x (combine y z)</a></code></pre></div>
 <p>As an example, here are the <code>Eq</code> and <code>Ord</code> instances for a simple pair type. Note how the definition uses the minimal complete definition rules by only defining <code>==</code> and <code>&lt;=</code>.</p>
-<div class="sourceCode" id="cb371"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb371-1" data-line-number="1"><span class="kw">data</span> <span class="dt">IntPair</span> <span class="fu">=</span> <span class="dt">IntPair</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb371-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb371-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb371-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntPair</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb371-5" data-line-number="5">  <span class="dt">IntPair</span> a1 a2 <span class="fu">==</span> <span class="dt">IntPair</span> b1 b2  <span class="fu">=</span>  a1<span class="fu">==</span>b1 <span class="fu">&amp;&amp;</span> a2<span class="fu">==</span>b2</a>
-<a class="sourceLine" id="cb371-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb371-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">IntPair</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb371-8" data-line-number="8">  <span class="dt">IntPair</span> a1 a2 <span class="fu">&lt;=</span> <span class="dt">IntPair</span> b1 b2</a>
-<a class="sourceLine" id="cb371-9" data-line-number="9">     <span class="fu">|</span> a1<span class="fu">&lt;</span>b1     <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb371-10" data-line-number="10">     <span class="fu">|</span> a1<span class="fu">&gt;</span>b1     <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb371-11" data-line-number="11">     <span class="fu">|</span> otherwise <span class="fu">=</span> a2<span class="fu">&lt;=</span>b2</a></code></pre></div>
-<div class="sourceCode" id="cb372"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb372-1" data-line-number="1"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="fu">&lt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb372-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb372-3" data-line-number="3"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb372-4" data-line-number="4"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb372-5" data-line-number="5"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> compare (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb372-6" data-line-number="6"><span class="dt">LT</span></a>
-<a class="sourceLine" id="cb372-7" data-line-number="7"><span class="fu">*</span><span class="dt">Main</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort [<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">4</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb372-8" data-line-number="8">[<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">4</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb371"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb371-1" title="1"><span class="kw">data</span> <span class="dt">IntPair</span> <span class="fu">=</span> <span class="dt">IntPair</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb371-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb371-3" title="3"></a>
+<a class="sourceLine" id="cb371-4" title="4"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntPair</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb371-5" title="5">  <span class="dt">IntPair</span> a1 a2 <span class="fu">==</span> <span class="dt">IntPair</span> b1 b2  <span class="fu">=</span>  a1<span class="fu">==</span>b1 <span class="fu">&amp;&amp;</span> a2<span class="fu">==</span>b2</a>
+<a class="sourceLine" id="cb371-6" title="6"></a>
+<a class="sourceLine" id="cb371-7" title="7"><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">IntPair</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb371-8" title="8">  <span class="dt">IntPair</span> a1 a2 <span class="fu">&lt;=</span> <span class="dt">IntPair</span> b1 b2</a>
+<a class="sourceLine" id="cb371-9" title="9">     <span class="fu">|</span> a1<span class="fu">&lt;</span>b1     <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb371-10" title="10">     <span class="fu">|</span> a1<span class="fu">&gt;</span>b1     <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb371-11" title="11">     <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> a2<span class="fu">&lt;=</span>b2</a></code></pre></div>
+<div class="sourceCode" id="cb372"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb372-1" title="1"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="fu">&lt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb372-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb372-3" title="3"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="fu">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb372-4" title="4"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb372-5" title="5"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">compare</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb372-6" title="6"><span class="dt">LT</span></a>
+<a class="sourceLine" id="cb372-7" title="7"><span class="fu">*</span><span class="dt">Main</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> [<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">4</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb372-8" title="8">[<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">4</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">1</span>,<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">2</span>]</a></code></pre></div>
 <h2 id="useful-stuff"><span class="header-section-number">6.4</span> Useful Stuff</h2>
 <h3 id="deriving"><span class="header-section-number">6.4.1</span> Deriving</h3>
 <p>As we’ve seen many times already, <code>deriving</code> is a way to get automatically generated class instances. The <code>Read</code> and <code>Show</code> classes should pretty much always be derived to get the standard behaviour. The derived instance for <code>Eq</code> is typically what you want. It requires constructors and fields to match.</p>
 <p>The derived <code>Ord</code> instance might not be what you want. It orders constructors left-to-right, and then compares fields inside constructors left-to-right. An example:</p>
-<div class="sourceCode" id="cb373"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb373-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Dead</span> <span class="fu">|</span> <span class="dt">Alive</span> <span class="dt">String</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb373-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb374"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb374-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Dead</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Bob&quot;</span> <span class="dv">35</span>                   <span class="co">-- constructors are ordered left-to-right</span></a>
-<a class="sourceLine" id="cb374-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb374-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Barbara&quot;</span> <span class="dv">35</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span>   <span class="co">-- names are compared before ages</span></a>
-<a class="sourceLine" id="cb374-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb374-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">30</span>     <span class="co">-- finally, ages are compared if names match</span></a>
-<a class="sourceLine" id="cb374-6" data-line-number="6"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb373"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb373-1" title="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Dead</span> <span class="fu">|</span> <span class="dt">Alive</span> <span class="dt">String</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb373-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb374"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb374-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Dead</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Bob&quot;</span> <span class="dv">35</span>                   <span class="co">-- constructors are ordered left-to-right</span></a>
+<a class="sourceLine" id="cb374-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb374-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Barbara&quot;</span> <span class="dv">35</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span>   <span class="co">-- names are compared before ages</span></a>
+<a class="sourceLine" id="cb374-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb374-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span> <span class="fu">&lt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">30</span>     <span class="co">-- finally, ages are compared if names match</span></a>
+<a class="sourceLine" id="cb374-6" title="6"><span class="dt">True</span></a></code></pre></div>
 <h3 id="asking-ghci-about-classes"><span class="header-section-number">6.4.2</span> Asking GHCi About Classes</h3>
 <p>You can use the <code>:info</code> command in GHCi to get the contents and instances of a class. These days the info even includes the minimal complete definition (see the MINIMAL pragma). For example:</p>
-<div class="sourceCode" id="cb375"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb375-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Num</span></a>
-<a class="sourceLine" id="cb375-2" data-line-number="2"><span class="kw">class</span> <span class="dt">Num</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb375-3" data-line-number="3"><span class="ot">  (+) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-4" data-line-number="4"><span class="ot">  (-) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-5" data-line-number="5"><span class="ot">  (*) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-6" data-line-number="6"><span class="ot">  negate ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-7" data-line-number="7"><span class="ot">  abs ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-8" data-line-number="8"><span class="ot">  signum ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-9" data-line-number="9"><span class="ot">  fromInteger ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb375-10" data-line-number="10">  <span class="ot">{-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}</span></a>
-<a class="sourceLine" id="cb375-11" data-line-number="11">    <span class="co">-- Defined in ‘GHC.Num’</span></a>
-<a class="sourceLine" id="cb375-12" data-line-number="12"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Word</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
-<a class="sourceLine" id="cb375-13" data-line-number="13"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Integer</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
-<a class="sourceLine" id="cb375-14" data-line-number="14"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Int</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
-<a class="sourceLine" id="cb375-15" data-line-number="15"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Float</span> <span class="co">-- Defined in ‘GHC.Float’</span></a>
-<a class="sourceLine" id="cb375-16" data-line-number="16"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Double</span> <span class="co">-- Defined in ‘GHC.Float’</span></a></code></pre></div>
+<div class="sourceCode" id="cb375"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb375-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Num</span></a>
+<a class="sourceLine" id="cb375-2" title="2"><span class="kw">class</span> <span class="dt">Num</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb375-3" title="3"><span class="ot">  (+) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-4" title="4"><span class="ot">  (-) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-5" title="5"><span class="ot">  (*) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-6" title="6"><span class="ot">  negate ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-7" title="7"><span class="ot">  abs ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-8" title="8"><span class="ot">  signum ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-9" title="9"><span class="ot">  fromInteger ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb375-10" title="10">  <span class="ot">{-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}</span></a>
+<a class="sourceLine" id="cb375-11" title="11">    <span class="co">-- Defined in ‘GHC.Num’</span></a>
+<a class="sourceLine" id="cb375-12" title="12"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Word</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
+<a class="sourceLine" id="cb375-13" title="13"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Integer</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
+<a class="sourceLine" id="cb375-14" title="14"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Int</span> <span class="co">-- Defined in ‘GHC.Num’</span></a>
+<a class="sourceLine" id="cb375-15" title="15"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Float</span> <span class="co">-- Defined in ‘GHC.Float’</span></a>
+<a class="sourceLine" id="cb375-16" title="16"><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Double</span> <span class="co">-- Defined in ‘GHC.Float’</span></a></code></pre></div>
 <h2 id="hierarchies"><span class="header-section-number">6.5</span> Hierarchies</h2>
 <p>Both classes and instances can form <em>hierarchies</em>. This means that a class or instance depends on another class or instance.</p>
 <h3 id="instance-hierarchies"><span class="header-section-number">6.5.1</span> Instance Hierarchies</h3>
 <p>Let’s try to define an <code>Eq</code> instance for a simple pair type:</p>
-<div class="sourceCode" id="cb376"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb376-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">MakePair</span> a a</a>
-<a class="sourceLine" id="cb376-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb376-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb376-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb376-5" data-line-number="5">  (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b)   <span class="fu">=</span>   x<span class="fu">==</span>a <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>b</a></code></pre></div>
-<div class="sourceCode" id="cb377"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb377-1" data-line-number="1">error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb377-2" data-line-number="2">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> a) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
-<a class="sourceLine" id="cb377-3" data-line-number="3">      <span class="dt">Possible</span> fix<span class="fu">:</span> add (<span class="dt">Eq</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</a>
-<a class="sourceLine" id="cb377-4" data-line-number="4">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘(<span class="fu">&amp;&amp;</span>)’, namely ‘x <span class="fu">==</span> a’</a>
-<a class="sourceLine" id="cb377-5" data-line-number="5">      <span class="dt">In</span> the expression<span class="fu">:</span> x <span class="fu">==</span> a <span class="fu">&amp;&amp;</span> y <span class="fu">==</span> b</a>
-<a class="sourceLine" id="cb377-6" data-line-number="6">      <span class="dt">In</span> an equation for ‘<span class="fu">==</span>’<span class="fu">:</span></a>
-<a class="sourceLine" id="cb377-7" data-line-number="7">          (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b) <span class="fu">=</span> x <span class="fu">==</span> a <span class="fu">&amp;&amp;</span> y <span class="fu">==</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb376"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb376-1" title="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">MakePair</span> a a</a>
+<a class="sourceLine" id="cb376-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb376-3" title="3"></a>
+<a class="sourceLine" id="cb376-4" title="4"><span class="kw">instance</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb376-5" title="5">  (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b)   <span class="fu">=</span>   x<span class="fu">==</span>a <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>b</a></code></pre></div>
+<div class="sourceCode" id="cb377"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb377-1" title="1"><span class="fu">error:</span></a>
+<a class="sourceLine" id="cb377-2" title="2">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> a) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
+<a class="sourceLine" id="cb377-3" title="3">      <span class="dt">Possible</span> fix<span class="fu">:</span> add (<span class="dt">Eq</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</a>
+<a class="sourceLine" id="cb377-4" title="4">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘(<span class="fu">&amp;&amp;</span>)’, namely ‘x <span class="fu">==</span> a’</a>
+<a class="sourceLine" id="cb377-5" title="5">      <span class="dt">In</span> the expression<span class="fu">:</span> x <span class="fu">==</span> a <span class="fu">&amp;&amp;</span> y <span class="fu">==</span> b</a>
+<a class="sourceLine" id="cb377-6" title="6">      <span class="dt">In</span> an equation for ‘<span class="fu">==</span>’<span class="fu">:</span></a>
+<a class="sourceLine" id="cb377-7" title="7">          (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b) <span class="fu">=</span> x <span class="fu">==</span> a <span class="fu">&amp;&amp;</span> y <span class="fu">==</span> b</a></code></pre></div>
 <p>The compiler is trying to tell us that our <code>Eq (Pair a)</code> instance needs an <code>Eq a</code> instance to work. How can we compare pairs of values of type <code>a</code> if we can’t compare values of type <code>a</code>? To solve this we need to add a type constraint to the instance declaration, just like we’ve added type constraints to function definitions.</p>
-<div class="sourceCode" id="cb378"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb378-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb378-2" data-line-number="2">  (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b)   <span class="fu">=</span>   x<span class="fu">==</span>a <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>b</a></code></pre></div>
+<div class="sourceCode" id="cb378"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb378-1" title="1"><span class="kw">instance</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb378-2" title="2">  (<span class="dt">MakePair</span> x y) <span class="fu">==</span> (<span class="dt">MakePair</span> a b)   <span class="fu">=</span>   x<span class="fu">==</span>a <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>b</a></code></pre></div>
 <p>Now we can compare pairs, as long as the element type is comparable. However, we can’t compare, say, pairs of functions, since functions don’t have an Eq instance.</p>
-<div class="sourceCode" id="cb379"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb379-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb379-2" data-line-number="2"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb379-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MakePair</span> reverse reverse <span class="fu">==</span> <span class="dt">MakePair</span> reverse reverse</a>
-<a class="sourceLine" id="cb379-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb379-5" data-line-number="5"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">15</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb379-6" data-line-number="6">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> ([a0] <span class="ot">-&gt;</span> [a0])) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
-<a class="sourceLine" id="cb379-7" data-line-number="7">        (maybe you haven&#39;t applied a function to enough arguments<span class="fu">?</span>)</a>
-<a class="sourceLine" id="cb379-8" data-line-number="8">    • <span class="dt">In</span> the expression<span class="fu">:</span></a>
-<a class="sourceLine" id="cb379-9" data-line-number="9">        <span class="dt">MakePair</span> reverse reverse <span class="fu">==</span> <span class="dt">MakePair</span> reverse reverse</a>
-<a class="sourceLine" id="cb379-10" data-line-number="10">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span></a>
-<a class="sourceLine" id="cb379-11" data-line-number="11">          it <span class="fu">=</span> <span class="dt">MakePair</span> reverse reverse <span class="fu">==</span> <span class="dt">MakePair</span> reverse reverse</a></code></pre></div>
+<div class="sourceCode" id="cb379"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb379-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span> <span class="fu">==</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb379-2" title="2"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb379-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="fu">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></a>
+<a class="sourceLine" id="cb379-4" title="4"></a>
+<a class="sourceLine" id="cb379-5" title="5"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">15</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb379-6" title="6">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Eq</span> ([a0] <span class="ot">-&gt;</span> [a0])) arising from a use <span class="kw">of</span> ‘<span class="fu">==</span>’</a>
+<a class="sourceLine" id="cb379-7" title="7">        (<span class="fu">maybe</span> you haven&#39;t applied a function to enough arguments<span class="fu">?</span>)</a>
+<a class="sourceLine" id="cb379-8" title="8">    • <span class="dt">In</span> the expression<span class="fu">:</span></a>
+<a class="sourceLine" id="cb379-9" title="9">        <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="fu">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></a>
+<a class="sourceLine" id="cb379-10" title="10">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span></a>
+<a class="sourceLine" id="cb379-11" title="11">          it <span class="fu">=</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="fu">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></a></code></pre></div>
 <p>Let’s continue with another example. Here’s a simple type class and an instance</p>
-<div class="sourceCode" id="cb380"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb380-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Check</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb380-2" data-line-number="2"><span class="ot">  check ::</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb380-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb380-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Check</span> <span class="dt">Int</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb380-5" data-line-number="5">  check x <span class="fu">=</span> x <span class="fu">&gt;</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb380"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb380-1" title="1"><span class="kw">class</span> <span class="dt">Check</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb380-2" title="2"><span class="ot">  check ::</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb380-3" title="3"></a>
+<a class="sourceLine" id="cb380-4" title="4"><span class="kw">instance</span> <span class="dt">Check</span> <span class="dt">Int</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb380-5" title="5">  check x <span class="fu">=</span> x <span class="fu">&gt;</span> <span class="dv">0</span></a></code></pre></div>
 <p>Now we can write a function that checks a list. We use the standard library function <code>and :: [Bool] -&gt; Bool</code> that checks if a list is all <code>True</code>s.</p>
-<div class="sourceCode" id="cb381"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb381-1" data-line-number="1"><span class="ot">checkAll ::</span> <span class="dt">Check</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb381-2" data-line-number="2">checkAll <span class="fu">=</span> and (map check xs)</a></code></pre></div>
+<div class="sourceCode" id="cb381"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb381-1" title="1"><span class="ot">checkAll ::</span> <span class="dt">Check</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb381-2" title="2">checkAll <span class="fu">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</a></code></pre></div>
 <p>In order to turn this into a <code>Check [a]</code> instance, we need to add a constraint to the instance declaration. Our <code>Check [a]</code> is based on the <code>Check a</code> instance.</p>
-<div class="sourceCode" id="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb382-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Check</span> a <span class="ot">=&gt;</span> <span class="dt">Check</span> [a] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb382-2" data-line-number="2">  check xs <span class="fu">=</span> and (map check xs)</a></code></pre></div>
+<div class="sourceCode" id="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb382-1" title="1"><span class="kw">instance</span> <span class="dt">Check</span> a <span class="ot">=&gt;</span> <span class="dt">Check</span> [a] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb382-2" title="2">  check xs <span class="fu">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</a></code></pre></div>
 <p>This means that our <code>Check [a]</code> instance is only valid when there is a corresponding <code>Check a</code> instance. For example, if we try to invoke a <code>Check [Bool]</code> instance, we get an error about the missing <code>Check Bool</code> instance:</p>
-<div class="sourceCode" id="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb383-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> check [<span class="dt">True</span>,<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb383-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb383-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb383-4" data-line-number="4">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Check</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘check’</a>
-<a class="sourceLine" id="cb383-5" data-line-number="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb383-6" data-line-number="6">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb383-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> check [<span class="dt">True</span>,<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb383-2" title="2"></a>
+<a class="sourceLine" id="cb383-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb383-4" title="4">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Check</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘check’</a>
+<a class="sourceLine" id="cb383-5" title="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb383-6" title="6">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</a></code></pre></div>
 <p>Also, if we try to define <code>Check [a]</code> instance without the constraint, we get an error (with a pretty good suggestion!)</p>
-<div class="sourceCode" id="cb384"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb384-1" data-line-number="1">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Check</span> a) arising from a use <span class="kw">of</span> ‘check’</a>
-<a class="sourceLine" id="cb384-2" data-line-number="2">      <span class="dt">Possible</span> fix<span class="fu">:</span></a>
-<a class="sourceLine" id="cb384-3" data-line-number="3">        add (<span class="dt">Check</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</a></code></pre></div>
+<div class="sourceCode" id="cb384"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb384-1" title="1">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Check</span> a) arising from a use <span class="kw">of</span> ‘check’</a>
+<a class="sourceLine" id="cb384-2" title="2">      <span class="dt">Possible</span> fix<span class="fu">:</span></a>
+<a class="sourceLine" id="cb384-3" title="3">        add (<span class="dt">Check</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</a></code></pre></div>
 <p>If you think about it, this instance hierarchy allows us to circumvent the limitation that we can’t make a <code>Check [Int]</code> instance.</p>
 <p>Finally, sometimes multiple constraints are needed. Consider for example the <code>Eq</code> instance for <code>Either</code>:</p>
-<div class="sourceCode" id="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb385-1" data-line-number="1"><span class="kw">instance</span> (<span class="dt">Eq</span> a, <span class="dt">Eq</span> b) <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Either</span> a b) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb385-2" data-line-number="2">  <span class="dt">Left</span> x  <span class="fu">==</span> <span class="dt">Left</span> y   <span class="fu">=</span>  x<span class="fu">==</span>y</a>
-<a class="sourceLine" id="cb385-3" data-line-number="3">  <span class="dt">Right</span> x <span class="fu">==</span> <span class="dt">Right</span> y  <span class="fu">=</span>  x<span class="fu">==</span>y</a>
-<a class="sourceLine" id="cb385-4" data-line-number="4">  _       <span class="fu">==</span> _        <span class="fu">=</span>  <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb385-1" title="1"><span class="kw">instance</span> (<span class="dt">Eq</span> a, <span class="dt">Eq</span> b) <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Either</span> a b) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb385-2" title="2">  <span class="dt">Left</span> x  <span class="fu">==</span> <span class="dt">Left</span> y   <span class="fu">=</span>  x<span class="fu">==</span>y</a>
+<a class="sourceLine" id="cb385-3" title="3">  <span class="dt">Right</span> x <span class="fu">==</span> <span class="dt">Right</span> y  <span class="fu">=</span>  x<span class="fu">==</span>y</a>
+<a class="sourceLine" id="cb385-4" title="4">  _       <span class="fu">==</span> _        <span class="fu">=</span>  <span class="dt">False</span></a></code></pre></div>
 <h3 id="class-hierarchy"><span class="header-section-number">6.5.2</span> Class Hierarchy</h3>
 <p>Respectively, a class can depend on another class. This is useful for instance when you want to use functions from another class in your default implementations:</p>
-<div class="sourceCode" id="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb386-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb386-2" data-line-number="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb386-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb386-4" data-line-number="4"><span class="kw">class</span> <span class="dt">Size</span> a <span class="ot">=&gt;</span> <span class="dt">SizeBoth</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb386-5" data-line-number="5"><span class="ot">  sizeBoth ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb386-6" data-line-number="6">  sizeBoth x y <span class="fu">=</span> size x <span class="fu">+</span> size y</a></code></pre></div>
+<div class="sourceCode" id="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb386-1" title="1"><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb386-2" title="2"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb386-3" title="3"></a>
+<a class="sourceLine" id="cb386-4" title="4"><span class="kw">class</span> <span class="dt">Size</span> a <span class="ot">=&gt;</span> <span class="dt">SizeBoth</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb386-5" title="5"><span class="ot">  sizeBoth ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb386-6" title="6">  sizeBoth x y <span class="fu">=</span> size x <span class="fu">+</span> size y</a></code></pre></div>
 <p>In cases like this we say <code>SizeBoth</code> is a <em>subclass</em> of <code>Size</code>. Note again the confusion with object oriented programming. Examples of subclasses in the standard library include:</p>
-<div class="sourceCode" id="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb387-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Ord</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb387-2" data-line-number="2">  <span class="fu">...</span></a>
-<a class="sourceLine" id="cb387-3" data-line-number="3"><span class="kw">class</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Fractional</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb387-4" data-line-number="4">  <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb387-1" title="1"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Ord</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb387-2" title="2">  <span class="fu">...</span></a>
+<a class="sourceLine" id="cb387-3" title="3"><span class="kw">class</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Fractional</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb387-4" title="4">  <span class="fu">...</span></a></code></pre></div>
 <p>Another way to look at subclasses is that if you have a <code>class Main a =&gt; Sub a</code>, you must provide an <code>instance Main MyType</code> in order to be able to declare <code>instance Sub MyType</code>.</p>
 <h2 id="quiz-5"><span class="header-section-number">6.6</span> Quiz</h2>
 <p>What are the functions in the <code>Eq</code> class?</p>
@@ -3492,15 +3490,15 @@ Because <code>Nothing</code> is a constructor.
 </li>
 </ol>
 <p>Given the following definition of the class <code>BitOperations</code></p>
-<div class="sourceCode" id="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb388-1" data-line-number="1"><span class="kw">class</span> <span class="dt">BitOperations</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb388-2" data-line-number="2"><span class="ot">  bitNot ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb388-3" data-line-number="3">  bitNot x <span class="fu">=</span> bitNand bitTrue x</a>
-<a class="sourceLine" id="cb388-4" data-line-number="4"><span class="ot">  bitAnd ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb388-5" data-line-number="5">  bitAnd x y <span class="fu">=</span> bitNot (bitOr (bitNot x) (bitNot y))</a>
-<a class="sourceLine" id="cb388-6" data-line-number="6"><span class="ot">  bitOr ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb388-7" data-line-number="7">  bitOr x y <span class="fu">=</span> bitNot (bitAnd (bitNot x) (bitNot y))</a>
-<a class="sourceLine" id="cb388-8" data-line-number="8"><span class="ot">  bitNand ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb388-9" data-line-number="9">  bitNand x y <span class="fu">=</span> bitNot (bitAnd x y)</a></code></pre></div>
+<div class="sourceCode" id="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb388-1" title="1"><span class="kw">class</span> <span class="dt">BitOperations</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb388-2" title="2"><span class="ot">  bitNot ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb388-3" title="3">  bitNot x <span class="fu">=</span> bitNand bitTrue x</a>
+<a class="sourceLine" id="cb388-4" title="4"><span class="ot">  bitAnd ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb388-5" title="5">  bitAnd x y <span class="fu">=</span> bitNot (bitOr (bitNot x) (bitNot y))</a>
+<a class="sourceLine" id="cb388-6" title="6"><span class="ot">  bitOr ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb388-7" title="7">  bitOr x y <span class="fu">=</span> bitNot (bitAnd (bitNot x) (bitNot y))</a>
+<a class="sourceLine" id="cb388-8" title="8"><span class="ot">  bitNand ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb388-9" title="9">  bitNand x y <span class="fu">=</span> bitNot (bitAnd x y)</a></code></pre></div>
 <p>which set of operations is <em>not</em> a minimal complete definition of <code>BitOperations</code>?</p>
 <ol class="quiz">
 <li>
@@ -3552,84 +3550,84 @@ If I define an instance for <code>Num</code>, I also get an instance for <code>F
 <h2 id="modeling-with-boxes"><span class="header-section-number">7.1</span> Modeling with Boxes</h2>
 <p>Sometimes you don’t need a new type, but instead can just reuse a standard type. For example, repesenting car register plate numbers with <code>String</code>. However, if your code is full of <code>String</code>s, it can be easy to accidentally mix up e.g. a car’s model and registration in a function like <code>registerCar :: String -&gt; String -&gt; CarRegistry -&gt; CarRegistry</code>.</p>
 <p>For situations like this it’s common to create a new type that just contains a <code>String</code> (a “boxed” string):</p>
-<div class="sourceCode" id="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb389-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Plate</span> <span class="fu">=</span> <span class="dt">Plate</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb389-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb389-1" title="1"><span class="kw">data</span> <span class="dt">Plate</span> <span class="fu">=</span> <span class="dt">Plate</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb389-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a></code></pre></div>
 <p>We can now give <code>registerCar</code> a slightly nicer type, <code>String -&gt; Plate -&gt; CarRegistry -&gt; CarRegistry</code>. Additionally, we can restrict the operations that are possible on <code>Plate</code>s to a subset of those that are possible on strings. For example, there is no need to combine the register plate numbers of two cars. Thus we don’t need to offer a function <code>concatPlates :: Plate -&gt; Plate -&gt; Plate</code>. We can also define a <em>smart constructor</em> for <code>Plate</code> that checks that the register number is in the correct format:</p>
-<div class="sourceCode" id="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb390-1" data-line-number="1"><span class="ot">parsePlate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Plate</span></a>
-<a class="sourceLine" id="cb390-2" data-line-number="2">parsePlate string</a>
-<a class="sourceLine" id="cb390-3" data-line-number="3">  <span class="fu">|</span> correctPlateNumber string  <span class="fu">=</span>  <span class="dt">Just</span> (<span class="dt">Plate</span> string)</a>
-<a class="sourceLine" id="cb390-4" data-line-number="4">  <span class="fu">|</span> otherwise                  <span class="fu">=</span>  <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb390-1" title="1"><span class="ot">parsePlate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Plate</span></a>
+<a class="sourceLine" id="cb390-2" title="2">parsePlate string</a>
+<a class="sourceLine" id="cb390-3" title="3">  <span class="fu">|</span> correctPlateNumber string  <span class="fu">=</span>  <span class="dt">Just</span> (<span class="dt">Plate</span> string)</a>
+<a class="sourceLine" id="cb390-4" title="4">  <span class="fu">|</span> <span class="fu">otherwise</span>                  <span class="fu">=</span>  <span class="dt">Nothing</span></a></code></pre></div>
 <p>Here’s another example: representing money. If we just store money as <code>Int</code>s, the compiler won’t protect us from mistakes like multiplying money with money. If instead we implement our own <code>Money</code> type that wraps <code>Int</code>, we get type safety. Additionally, we can encapsulate the fact that money is represented as an integer amount of cents.</p>
-<div class="sourceCode" id="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb391-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb391-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb391-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb391-4" data-line-number="4"><span class="ot">renderMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb391-5" data-line-number="5">renderMoney (<span class="dt">Money</span> cents) <span class="fu">=</span> show (fromIntegral cents <span class="fu">/</span> <span class="dv">100</span>)</a>
-<a class="sourceLine" id="cb391-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb391-7" data-line-number="7"><span class="ot">(+!) ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb391-8" data-line-number="8">(<span class="dt">Money</span> a) <span class="fu">+!</span> (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a>
-<a class="sourceLine" id="cb391-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb391-10" data-line-number="10"><span class="ot">scale ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb391-11" data-line-number="11">scale (<span class="dt">Money</span> a) x <span class="fu">=</span> <span class="dt">Money</span> (round (fromIntegral a <span class="fu">*</span> x))</a>
-<a class="sourceLine" id="cb391-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb391-13" data-line-number="13"><span class="ot">addVat ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb391-14" data-line-number="14">addVat m <span class="fu">=</span> m <span class="fu">+!</span> scale m <span class="fl">0.24</span></a></code></pre></div>
-<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb392-1" data-line-number="1">renderMoney (<span class="dt">Money</span> <span class="dv">100</span> <span class="fu">+!</span> <span class="dt">Money</span> <span class="dv">150</span>)</a>
-<a class="sourceLine" id="cb392-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="st">&quot;2.5&quot;</span></a>
-<a class="sourceLine" id="cb392-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb392-4" data-line-number="4">scale (<span class="dt">Money</span> <span class="dv">299</span>) <span class="fl">0.24</span></a>
-<a class="sourceLine" id="cb392-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dt">Money</span> <span class="dv">72</span></a>
-<a class="sourceLine" id="cb392-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb392-7" data-line-number="7">addVat (<span class="dt">Money</span> <span class="dv">299</span>)</a>
-<a class="sourceLine" id="cb392-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dt">Money</span> <span class="dv">371</span></a></code></pre></div>
+<div class="sourceCode" id="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb391-1" title="1"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb391-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb391-3" title="3"></a>
+<a class="sourceLine" id="cb391-4" title="4"><span class="ot">renderMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb391-5" title="5">renderMoney (<span class="dt">Money</span> cents) <span class="fu">=</span> <span class="fu">show</span> (<span class="fu">fromIntegral</span> cents <span class="fu">/</span> <span class="dv">100</span>)</a>
+<a class="sourceLine" id="cb391-6" title="6"></a>
+<a class="sourceLine" id="cb391-7" title="7"><span class="ot">(+!) ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb391-8" title="8">(<span class="dt">Money</span> a) <span class="fu">+!</span> (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a>
+<a class="sourceLine" id="cb391-9" title="9"></a>
+<a class="sourceLine" id="cb391-10" title="10"><span class="ot">scale ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb391-11" title="11">scale (<span class="dt">Money</span> a) x <span class="fu">=</span> <span class="dt">Money</span> (<span class="fu">round</span> (<span class="fu">fromIntegral</span> a <span class="fu">*</span> x))</a>
+<a class="sourceLine" id="cb391-12" title="12"></a>
+<a class="sourceLine" id="cb391-13" title="13"><span class="ot">addVat ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb391-14" title="14">addVat m <span class="fu">=</span> m <span class="fu">+!</span> scale m <span class="fl">0.24</span></a></code></pre></div>
+<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb392-1" title="1">renderMoney (<span class="dt">Money</span> <span class="dv">100</span> <span class="fu">+!</span> <span class="dt">Money</span> <span class="dv">150</span>)</a>
+<a class="sourceLine" id="cb392-2" title="2">  <span class="fu">==&gt;</span> <span class="st">&quot;2.5&quot;</span></a>
+<a class="sourceLine" id="cb392-3" title="3"></a>
+<a class="sourceLine" id="cb392-4" title="4">scale (<span class="dt">Money</span> <span class="dv">299</span>) <span class="fl">0.24</span></a>
+<a class="sourceLine" id="cb392-5" title="5">  <span class="fu">==&gt;</span> <span class="dt">Money</span> <span class="dv">72</span></a>
+<a class="sourceLine" id="cb392-6" title="6"></a>
+<a class="sourceLine" id="cb392-7" title="7">addVat (<span class="dt">Money</span> <span class="dv">299</span>)</a>
+<a class="sourceLine" id="cb392-8" title="8">  <span class="fu">==&gt;</span> <span class="dt">Money</span> <span class="dv">371</span></a></code></pre></div>
 <p><strong>Note!</strong> If you’re familiar with Object-Oriented Programming, this is a bit like encapsulation.</p>
 <h2 id="modeling-with-cases"><span class="header-section-number">7.2</span> Modeling with Cases</h2>
 <p>Haskell’s algebraic datatypes are really powerful at modeling things based on <em>cases</em>. It’s often useful to think of types as defining the set of possible cases, and functions <em>handling</em> those cases (often via pattern matching). Let’s look at two examples.</p>
 <p>Since it’s so easy to define custom types in Haskell, it’s quite convenient to use more descriptive types instead of booleans or strings. Consider a list of persons. In some other language if you wanted to sort the persons into ascending order by name you might use a call like <code>sortPersons(persons, &quot;name&quot;, true)</code>. In Haskell you can do this instead:</p>
-<div class="sourceCode" id="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb393-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span> {<span class="ot">name ::</span> <span class="dt">String</span>,<span class="ot"> age ::</span> <span class="dt">Int</span>}</a>
-<a class="sourceLine" id="cb393-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb393-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb393-4" data-line-number="4"><span class="kw">data</span> <span class="dt">SortOrder</span> <span class="fu">=</span> <span class="dt">Ascending</span> <span class="fu">|</span> <span class="dt">Descending</span></a>
-<a class="sourceLine" id="cb393-5" data-line-number="5"><span class="kw">data</span> <span class="dt">SortField</span> <span class="fu">=</span> <span class="dt">Name</span> <span class="fu">|</span> <span class="dt">Age</span></a>
-<a class="sourceLine" id="cb393-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb393-7" data-line-number="7"><span class="ot">sortByField ::</span> <span class="dt">SortField</span> <span class="ot">-&gt;</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
-<a class="sourceLine" id="cb393-8" data-line-number="8">sortByField <span class="dt">Name</span> ps <span class="fu">=</span> sortBy (comparing name) ps</a>
-<a class="sourceLine" id="cb393-9" data-line-number="9">sortByField <span class="dt">Age</span> ps <span class="fu">=</span> sortBy (comparing age) ps</a>
-<a class="sourceLine" id="cb393-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb393-11" data-line-number="11"><span class="ot">sortPersons ::</span> <span class="dt">SortField</span> <span class="ot">-&gt;</span> <span class="dt">SortOrder</span> <span class="ot">-&gt;</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
-<a class="sourceLine" id="cb393-12" data-line-number="12">sortPersons field <span class="dt">Ascending</span> ps <span class="fu">=</span> sortByField field ps</a>
-<a class="sourceLine" id="cb393-13" data-line-number="13">sortPersons field <span class="dt">Descending</span> ps <span class="fu">=</span> reverse (sortByField field ps)</a>
-<a class="sourceLine" id="cb393-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb393-15" data-line-number="15">persons <span class="fu">=</span> [<span class="dt">Person</span> <span class="st">&quot;Fridolf&quot;</span> <span class="dv">73</span>, <span class="dt">Person</span> <span class="st">&quot;Greta&quot;</span> <span class="dv">60</span>, <span class="dt">Person</span> <span class="st">&quot;Hans&quot;</span> <span class="dv">65</span>]</a></code></pre></div>
-<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb394-1" data-line-number="1">sortPersons <span class="dt">Name</span> <span class="dt">Ascending</span> persons</a>
-<a class="sourceLine" id="cb394-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="fu">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="fu">=</span> <span class="dv">60</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="fu">=</span> <span class="dv">65</span>}]</a>
-<a class="sourceLine" id="cb394-3" data-line-number="3">sortPersons <span class="dt">Age</span> <span class="dt">Descending</span> persons</a>
-<a class="sourceLine" id="cb394-4" data-line-number="4">  <span class="fu">==&gt;</span> [<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="fu">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="fu">=</span> <span class="dv">65</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="fu">=</span> <span class="dv">60</span>}]</a></code></pre></div>
+<div class="sourceCode" id="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb393-1" title="1"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span> {<span class="ot">name ::</span> <span class="dt">String</span>,<span class="ot"> age ::</span> <span class="dt">Int</span>}</a>
+<a class="sourceLine" id="cb393-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb393-3" title="3"></a>
+<a class="sourceLine" id="cb393-4" title="4"><span class="kw">data</span> <span class="dt">SortOrder</span> <span class="fu">=</span> <span class="dt">Ascending</span> <span class="fu">|</span> <span class="dt">Descending</span></a>
+<a class="sourceLine" id="cb393-5" title="5"><span class="kw">data</span> <span class="dt">SortField</span> <span class="fu">=</span> <span class="dt">Name</span> <span class="fu">|</span> <span class="dt">Age</span></a>
+<a class="sourceLine" id="cb393-6" title="6"></a>
+<a class="sourceLine" id="cb393-7" title="7"><span class="ot">sortByField ::</span> <span class="dt">SortField</span> <span class="ot">-&gt;</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
+<a class="sourceLine" id="cb393-8" title="8">sortByField <span class="dt">Name</span> ps <span class="fu">=</span> sortBy (comparing name) ps</a>
+<a class="sourceLine" id="cb393-9" title="9">sortByField <span class="dt">Age</span> ps <span class="fu">=</span> sortBy (comparing age) ps</a>
+<a class="sourceLine" id="cb393-10" title="10"></a>
+<a class="sourceLine" id="cb393-11" title="11"><span class="ot">sortPersons ::</span> <span class="dt">SortField</span> <span class="ot">-&gt;</span> <span class="dt">SortOrder</span> <span class="ot">-&gt;</span> [<span class="dt">Person</span>] <span class="ot">-&gt;</span> [<span class="dt">Person</span>]</a>
+<a class="sourceLine" id="cb393-12" title="12">sortPersons field <span class="dt">Ascending</span> ps <span class="fu">=</span> sortByField field ps</a>
+<a class="sourceLine" id="cb393-13" title="13">sortPersons field <span class="dt">Descending</span> ps <span class="fu">=</span> <span class="fu">reverse</span> (sortByField field ps)</a>
+<a class="sourceLine" id="cb393-14" title="14"></a>
+<a class="sourceLine" id="cb393-15" title="15">persons <span class="fu">=</span> [<span class="dt">Person</span> <span class="st">&quot;Fridolf&quot;</span> <span class="dv">73</span>, <span class="dt">Person</span> <span class="st">&quot;Greta&quot;</span> <span class="dv">60</span>, <span class="dt">Person</span> <span class="st">&quot;Hans&quot;</span> <span class="dv">65</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb394-1" title="1">sortPersons <span class="dt">Name</span> <span class="dt">Ascending</span> persons</a>
+<a class="sourceLine" id="cb394-2" title="2">  <span class="fu">==&gt;</span> [<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="fu">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="fu">=</span> <span class="dv">60</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="fu">=</span> <span class="dv">65</span>}]</a>
+<a class="sourceLine" id="cb394-3" title="3">sortPersons <span class="dt">Age</span> <span class="dt">Descending</span> persons</a>
+<a class="sourceLine" id="cb394-4" title="4">  <span class="fu">==&gt;</span> [<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="fu">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="fu">=</span> <span class="dv">65</span>},<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="fu">=</span> <span class="dv">60</span>}]</a></code></pre></div>
 <p>Note how you can’t accidentally typo the field name (unlike with strings), and how you don’t need to remember whether <code>true</code> refers to ascending or descending order.</p>
 <p>Let’s move on to the next example. Many Haskell functions don’t work with empty lists (consider <code>head []</code>). If you’re writing code that needs to track whether lists are possibly empty or guaranteed to not be empty, you can use the <code>NonEmpty</code> type from the <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-List-NonEmpty.html">Data.List.NonEmpty</a> module.</p>
 <p>Consider the definition of <code>NonEmpty</code>:</p>
-<div class="sourceCode" id="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb395-1" data-line-number="1"><span class="kw">data</span> <span class="dt">NonEmpty</span> a <span class="fu">=</span> a <span class="fu">:|</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb395-1" title="1"><span class="kw">data</span> <span class="dt">NonEmpty</span> a <span class="fu">=</span> a <span class="fu">:|</span> [a]</a></code></pre></div>
 <p>Here the type represents a <em>lack of</em> cases. The type <code>NonEmpty a</code> will always consist of a value of type <code>a</code>, and some further <code>a</code>s, collected in a list. Here are some example values of <code>NonEmpty Int</code>:</p>
-<div class="sourceCode" id="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb396-1" data-line-number="1"><span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb396-2" data-line-number="2"><span class="dv">1</span> <span class="fu">:|</span> []</a></code></pre></div>
+<div class="sourceCode" id="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb396-1" title="1"><span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb396-2" title="2"><span class="dv">1</span> <span class="fu">:|</span> []</a></code></pre></div>
 <p>By the way, this is also an example of an <em>infix constructor</em>. We’ve already met another infix constructor earlier, the list constructor <code>(:)</code>. Any operator that begins with a colon (the <code>:</code> character) can be used as an infix constructor. We can pattern match on <code>(:|)</code> just like on <code>(:)</code>, as you’ll see in the examples below.</p>
 <p>Here are the functions that convert between normal lists and nonempty lists. Note how we can’t have a function <code>[a] -&gt; NonEmpty a</code>, but must instead use <code>Maybe</code> to represent the possibility that the list was, indeed, empty. Note also how <code>toList</code> has only one equation, we can’t have a <code>toList []</code> situation due to the type <code>NonEmpty</code>.</p>
-<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb397-1" data-line-number="1"><span class="ot">nonEmpty ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> (<span class="dt">NonEmpty</span> a)</a>
-<a class="sourceLine" id="cb397-2" data-line-number="2">nonEmpty [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb397-3" data-line-number="3">nonEmpty (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> (x <span class="fu">:|</span> xs)</a>
-<a class="sourceLine" id="cb397-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb397-5" data-line-number="5"><span class="ot">toList ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb397-6" data-line-number="6">toList (x <span class="fu">:|</span> xs) <span class="fu">=</span> x <span class="fu">:</span> xs</a></code></pre></div>
-<div class="sourceCode" id="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb398-1" data-line-number="1">nonEmpty [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]     <span class="fu">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb398-2" data-line-number="2">nonEmpty [<span class="dv">1</span>]         <span class="fu">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="fu">:|</span> [])</a>
-<a class="sourceLine" id="cb398-3" data-line-number="3">nonEmpty []          <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb398-4" data-line-number="4">toList (<span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb397-1" title="1"><span class="ot">nonEmpty ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> (<span class="dt">NonEmpty</span> a)</a>
+<a class="sourceLine" id="cb397-2" title="2">nonEmpty [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb397-3" title="3">nonEmpty (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> (x <span class="fu">:|</span> xs)</a>
+<a class="sourceLine" id="cb397-4" title="4"></a>
+<a class="sourceLine" id="cb397-5" title="5"><span class="ot">toList ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb397-6" title="6">toList (x <span class="fu">:|</span> xs) <span class="fu">=</span> x <span class="fu">:</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb398-1" title="1">nonEmpty [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]     <span class="fu">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb398-2" title="2">nonEmpty [<span class="dv">1</span>]         <span class="fu">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="fu">:|</span> [])</a>
+<a class="sourceLine" id="cb398-3" title="3">nonEmpty []          <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb398-4" title="4">toList (<span class="dv">1</span> <span class="fu">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>Here are <code>head</code> and <code>last</code> implemented for <code>NonEmpty</code>:</p>
-<div class="sourceCode" id="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb399-1" data-line-number="1">neHead (x <span class="fu">:|</span> _) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb399-2" data-line-number="2">neLast (x <span class="fu">:|</span> []) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb399-3" data-line-number="3">neLast (_ <span class="fu">:|</span> xs) <span class="fu">=</span> last xs</a></code></pre></div>
-<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb400-1" data-line-number="1">neHead (<span class="dv">1</span><span class="fu">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  <span class="dv">1</span></a>
-<a class="sourceLine" id="cb400-2" data-line-number="2">neLast (<span class="dv">1</span><span class="fu">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb399-1" title="1">neHead (x <span class="fu">:|</span> _) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb399-2" title="2">neLast (x <span class="fu">:|</span> []) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb399-3" title="3">neLast (_ <span class="fu">:|</span> xs) <span class="fu">=</span> <span class="fu">last</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb400-1" title="1">neHead (<span class="dv">1</span><span class="fu">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  <span class="dv">1</span></a>
+<a class="sourceLine" id="cb400-2" title="2">neLast (<span class="dv">1</span><span class="fu">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="fu">==&gt;</span>  <span class="dv">3</span></a></code></pre></div>
 <p>By the way, these functions are available as <code>Data.List.NonEmpty.head</code> and <code>Data.List.NonEmpty.last</code> along with many other useful functions.</p>
 <p>In summary, if you write types that represent all possible cases for your values, and then write functions that handle those cases, your code will be simple and correct.</p>
 <h2 id="monoids"><span class="header-section-number">7.3</span> Monoids</h2>
@@ -3638,196 +3636,196 @@ If I define an instance for <code>Num</code>, I also get an instance for <code>F
 <p>A pattern that comes up surprisingly often in functional programming is the <em>monoid</em> (not to be confused with a <em>monad</em>!). Explanations of monoids are often very mathematical, but the idea is simple: combining things.</p>
 <h3 id="associative-operations"><span class="header-section-number">7.3.1</span> Associative Operations</h3>
 <p>Many functions and operators we use are <em>associative</em>. This is just a fancy way of saying they don’t need parentheses. For example, all of these expressions have the value 16 because addition is associative:</p>
-<div class="sourceCode" id="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb401-1" data-line-number="1">(<span class="dv">1</span> <span class="fu">+</span>  <span class="dv">3</span>) <span class="fu">+</span> (<span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span>)</a>
-<a class="sourceLine" id="cb401-2" data-line-number="2"> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">3</span>  <span class="fu">+</span> (<span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span>))</a>
-<a class="sourceLine" id="cb401-3" data-line-number="3"> <span class="dv">1</span>  <span class="fu">+</span> <span class="dv">3</span>  <span class="fu">+</span>  <span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span></a></code></pre></div>
+<div class="sourceCode" id="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb401-1" title="1">(<span class="dv">1</span> <span class="fu">+</span>  <span class="dv">3</span>) <span class="fu">+</span> (<span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span>)</a>
+<a class="sourceLine" id="cb401-2" title="2"> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">3</span>  <span class="fu">+</span> (<span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span>))</a>
+<a class="sourceLine" id="cb401-3" title="3"> <span class="dv">1</span>  <span class="fu">+</span> <span class="dv">3</span>  <span class="fu">+</span>  <span class="dv">5</span> <span class="fu">+</span> <span class="dv">7</span></a></code></pre></div>
 <p>Examples of associative operations are easy to come by in Haskell. For example the <code>++</code> operator for catenating lists is associative: it doesn’t matter whether you do <code>([1] ++ [2,3]) ++ [4]</code> or <code>[1] ++ ([2,3] ++ [4])</code> – the result is <code>[1,2,3,4]</code>.</p>
 <p>Another great example is the function composition operator. Both <code>(head . tail) . tail</code> and <code>head . (tail . tail)</code> compute the third element of a list.</p>
 <p>However not all operators are associative. The most familiar examples are subtraction and exponentiation. <code>(1-2)-3</code> is <code>-4</code> but <code>1-(2-3)</code> is <code>2</code>. Similarly, <code>(2^3)^2</code> is <code>64</code> while <code>2^(3^2)</code> is 512. One needs to be careful with parentheses when using operators that are not associative.</p>
 <p>Another operator that’s not associative is the list constructor, <code>(:)</code>. This time the reason is even more fundamental: while <code>True:(False:[])</code> is ok, <code>(True:False):[]</code> does not even type! In order for an operation to be associative, it needs to take two arguments of the same type.</p>
 <p>In addition to operators, functions can also be associative. The syntax looks a bit different, but a function <code>f</code> is associative if these are the same:</p>
-<div class="sourceCode" id="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb402-1" data-line-number="1">f x (f y z)</a>
-<a class="sourceLine" id="cb402-2" data-line-number="2">f (f x y) z</a></code></pre></div>
+<div class="sourceCode" id="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb402-1" title="1">f x (f y z)</a>
+<a class="sourceLine" id="cb402-2" title="2">f (f x y) z</a></code></pre></div>
 <p>Two widely-used associative functions are the <code>min</code> and <code>max</code> functions:</p>
-<div class="sourceCode" id="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb403-1" data-line-number="1">min <span class="dv">2</span> (min <span class="dv">1</span> <span class="dv">3</span>) <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb403-2" data-line-number="2">min (min <span class="dv">2</span> <span class="dv">1</span>) <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb403-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb403-4" data-line-number="4">max <span class="dv">2</span> (max <span class="dv">1</span> <span class="dv">3</span>) <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb403-5" data-line-number="5">max (max <span class="dv">2</span> <span class="dv">1</span>) <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb403-1" title="1"><span class="fu">min</span> <span class="dv">2</span> (<span class="fu">min</span> <span class="dv">1</span> <span class="dv">3</span>) <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb403-2" title="2"><span class="fu">min</span> (<span class="fu">min</span> <span class="dv">2</span> <span class="dv">1</span>) <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb403-3" title="3"></a>
+<a class="sourceLine" id="cb403-4" title="4"><span class="fu">max</span> <span class="dv">2</span> (<span class="fu">max</span> <span class="dv">1</span> <span class="dv">3</span>) <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb403-5" title="5"><span class="fu">max</span> (<span class="fu">max</span> <span class="dv">2</span> <span class="dv">1</span>) <span class="dv">3</span> <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <h3 id="semigroups"><span class="header-section-number">7.3.2</span> Semigroups</h3>
 <p>Mathematically speaking, an associative function (or operator) forms a <em>semigroup</em>. Haskell has a type class <code>Semigroup</code> (defined in the module <code>Data.Semigroup</code>) that can be used when a type has one clear associative operation.</p>
-<div class="sourceCode" id="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb404-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb404-2" data-line-number="2">  <span class="co">-- An associative operation.</span></a>
-<a class="sourceLine" id="cb404-3" data-line-number="3"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb404-1" title="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb404-2" title="2">  <span class="co">-- An associative operation.</span></a>
+<a class="sourceLine" id="cb404-3" title="3"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p>Lists are an instance of <code>Semigroup</code> with <code>(++)</code> as <code>(&lt;&gt;)</code>:</p>
-<div class="sourceCode" id="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb405-1" data-line-number="1">[<span class="dv">1</span>] <span class="fu">&lt;&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&lt;&gt;</span> [<span class="dv">4</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb405-1" title="1">[<span class="dv">1</span>] <span class="fu">&lt;&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&lt;&gt;</span> [<span class="dv">4</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <p>Types that have multiple different associative operators usually aren’t made an instance of Semigroup. An example is <code>Int</code>, which has many associative functions like <code>+</code>, <code>*</code> and <code>max</code>. Instead, the Haskell standard library uses boxing (see earlier in this lecture). Here are the definitions for <code>Sum</code> and <code>Product</code>:</p>
-<div class="sourceCode" id="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb406-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Sum</span> a <span class="fu">=</span> <span class="dt">Sum</span> a</a>
-<a class="sourceLine" id="cb406-2" data-line-number="2"><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Semigroup</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb406-3" data-line-number="3">  <span class="dt">Sum</span> a <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> b  <span class="fu">=</span>  <span class="dt">Sum</span> (a<span class="fu">+</span>b)</a>
-<a class="sourceLine" id="cb406-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb406-5" data-line-number="5"><span class="kw">data</span> <span class="dt">Product</span> a <span class="fu">=</span> <span class="dt">Product</span> a</a>
-<a class="sourceLine" id="cb406-6" data-line-number="6"><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Semigroup</span> (<span class="dt">Product</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb406-7" data-line-number="7">  <span class="dt">Product</span> a <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> b   <span class="fu">=</span>  <span class="dt">Product</span> (a<span class="fu">*</span>b)</a></code></pre></div>
+<div class="sourceCode" id="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb406-1" title="1"><span class="kw">data</span> <span class="dt">Sum</span> a <span class="fu">=</span> <span class="dt">Sum</span> a</a>
+<a class="sourceLine" id="cb406-2" title="2"><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Semigroup</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb406-3" title="3">  <span class="dt">Sum</span> a <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> b  <span class="fu">=</span>  <span class="dt">Sum</span> (a<span class="fu">+</span>b)</a>
+<a class="sourceLine" id="cb406-4" title="4"></a>
+<a class="sourceLine" id="cb406-5" title="5"><span class="kw">data</span> <span class="dt">Product</span> a <span class="fu">=</span> <span class="dt">Product</span> a</a>
+<a class="sourceLine" id="cb406-6" title="6"><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Semigroup</span> (<span class="dt">Product</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb406-7" title="7">  <span class="dt">Product</span> a <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> b   <span class="fu">=</span>  <span class="dt">Product</span> (a<span class="fu">*</span>b)</a></code></pre></div>
 <p>By the way, this is another benefit of boxing things: being able to declare different type class instances!</p>
 <p>Similarly, we have box types <code>Min</code> and <code>Max</code>. Let’s play around in GHCi a bit:</p>
-<div class="sourceCode" id="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb407-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Semigroup</span></a>
-<a class="sourceLine" id="cb407-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Product</span> (<span class="dv">2</span><span class="ot">::</span><span class="dt">Int</span>) <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb407-3" data-line-number="3"><span class="dt">Product</span> {getProduct <span class="fu">=</span> <span class="dv">6</span>}</a>
-<a class="sourceLine" id="cb407-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Sum</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">5</span> <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb407-5" data-line-number="5"><span class="dt">Sum</span> {getSum <span class="fu">=</span> <span class="dv">15</span>}</a>
-<a class="sourceLine" id="cb407-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Product</span> <span class="dv">2</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb407-7" data-line-number="7"><span class="dt">Product</span> {getProduct <span class="fu">=</span> <span class="dv">6</span>}</a>
-<a class="sourceLine" id="cb407-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Min</span> <span class="dv">4</span> <span class="fu">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb407-9" data-line-number="9"><span class="dt">Min</span> {getMin <span class="fu">=</span> <span class="dv">3</span>}</a>
-<a class="sourceLine" id="cb407-10" data-line-number="10"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Max</span> <span class="dv">4</span> <span class="fu">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb407-11" data-line-number="11"><span class="dt">Max</span> {getMax <span class="fu">=</span> <span class="dv">5</span>}</a></code></pre></div>
+<div class="sourceCode" id="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb407-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Semigroup</span></a>
+<a class="sourceLine" id="cb407-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Product</span> (<span class="dv">2</span><span class="ot">::</span><span class="dt">Int</span>) <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb407-3" title="3"><span class="dt">Product</span> {getProduct <span class="fu">=</span> <span class="dv">6</span>}</a>
+<a class="sourceLine" id="cb407-4" title="4"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Sum</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">5</span> <span class="fu">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb407-5" title="5"><span class="dt">Sum</span> {getSum <span class="fu">=</span> <span class="dv">15</span>}</a>
+<a class="sourceLine" id="cb407-6" title="6"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Product</span> <span class="dv">2</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb407-7" title="7"><span class="dt">Product</span> {getProduct <span class="fu">=</span> <span class="dv">6</span>}</a>
+<a class="sourceLine" id="cb407-8" title="8"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Min</span> <span class="dv">4</span> <span class="fu">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb407-9" title="9"><span class="dt">Min</span> {getMin <span class="fu">=</span> <span class="dv">3</span>}</a>
+<a class="sourceLine" id="cb407-10" title="10"><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="fu">&gt;</span> <span class="dt">Max</span> <span class="dv">4</span> <span class="fu">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">3</span> <span class="fu">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb407-11" title="11"><span class="dt">Max</span> {getMax <span class="fu">=</span> <span class="dv">5</span>}</a></code></pre></div>
 <h3 id="finally-monoids"><span class="header-section-number">7.3.3</span> Finally, Monoids</h3>
 <p>If we listen to the mathematicians for a moment again, a <em>monoid</em> is a semigroup with a <em>neutral element</em>. A neutral element is a zero: an element that does nothing when combined with other elements. Here are some examples:</p>
-<div class="sourceCode" id="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb408-1" data-line-number="1"><span class="co">-- 0 is the neutral element of (+)</span></a>
-<a class="sourceLine" id="cb408-2" data-line-number="2"><span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>        <span class="fu">==&gt;</span>  <span class="dv">3</span></a>
-<a class="sourceLine" id="cb408-3" data-line-number="3"><span class="dv">0</span> <span class="fu">+</span> <span class="dv">3</span>        <span class="fu">==&gt;</span>  <span class="dv">3</span></a>
-<a class="sourceLine" id="cb408-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb408-5" data-line-number="5"><span class="co">-- 1 is the neutral element of (*)</span></a>
-<a class="sourceLine" id="cb408-6" data-line-number="6"><span class="dv">1</span> <span class="fu">*</span> <span class="dv">5</span>        <span class="fu">==&gt;</span>  <span class="dv">5</span></a>
-<a class="sourceLine" id="cb408-7" data-line-number="7"><span class="dv">5</span> <span class="fu">*</span> <span class="dv">1</span>        <span class="fu">==&gt;</span>  <span class="dv">5</span></a>
-<a class="sourceLine" id="cb408-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb408-9" data-line-number="9"><span class="co">-- [] is the neutral element of (++)</span></a>
-<a class="sourceLine" id="cb408-10" data-line-number="10">[] <span class="fu">++</span> [<span class="dv">1</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb408-11" data-line-number="11">[<span class="dv">1</span>,<span class="dv">2</span>] <span class="fu">++</span> []  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb408-1" title="1"><span class="co">-- 0 is the neutral element of (+)</span></a>
+<a class="sourceLine" id="cb408-2" title="2"><span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>        <span class="fu">==&gt;</span>  <span class="dv">3</span></a>
+<a class="sourceLine" id="cb408-3" title="3"><span class="dv">0</span> <span class="fu">+</span> <span class="dv">3</span>        <span class="fu">==&gt;</span>  <span class="dv">3</span></a>
+<a class="sourceLine" id="cb408-4" title="4"></a>
+<a class="sourceLine" id="cb408-5" title="5"><span class="co">-- 1 is the neutral element of (*)</span></a>
+<a class="sourceLine" id="cb408-6" title="6"><span class="dv">1</span> <span class="fu">*</span> <span class="dv">5</span>        <span class="fu">==&gt;</span>  <span class="dv">5</span></a>
+<a class="sourceLine" id="cb408-7" title="7"><span class="dv">5</span> <span class="fu">*</span> <span class="dv">1</span>        <span class="fu">==&gt;</span>  <span class="dv">5</span></a>
+<a class="sourceLine" id="cb408-8" title="8"></a>
+<a class="sourceLine" id="cb408-9" title="9"><span class="co">-- [] is the neutral element of (++)</span></a>
+<a class="sourceLine" id="cb408-10" title="10">[] <span class="fu">++</span> [<span class="dv">1</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb408-11" title="11">[<span class="dv">1</span>,<span class="dv">2</span>] <span class="fu">++</span> []  <span class="fu">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</a></code></pre></div>
 <p>The Haskell type class <code>Monoid</code> (from the module <code>Data.Monoid</code>) represents monoids.</p>
-<div class="sourceCode" id="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb409-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb409-2" data-line-number="2">  <span class="co">-- The neutral element</span></a>
-<a class="sourceLine" id="cb409-3" data-line-number="3"><span class="ot">  mempty ::</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb409-1" title="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb409-2" title="2">  <span class="co">-- The neutral element</span></a>
+<a class="sourceLine" id="cb409-3" title="3"><span class="ot">  mempty ::</span> a</a></code></pre></div>
 <p>Here are the <code>Monoid</code> instances corresponding to our three examples of neutral elements:</p>
-<div class="sourceCode" id="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb410-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Monoid</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb410-2" data-line-number="2">  mempty <span class="fu">=</span> <span class="dt">Sum</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb410-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb410-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Monoid</span> (<span class="dt">Product</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb410-5" data-line-number="5">  mempty <span class="fu">=</span> <span class="dt">Product</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb410-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb410-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">Monoid</span> [] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb410-8" data-line-number="8">  mempty <span class="fu">=</span> []</a></code></pre></div>
+<div class="sourceCode" id="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb410-1" title="1"><span class="kw">instance</span> <span class="dt">Monoid</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb410-2" title="2">  <span class="fu">mempty</span> <span class="fu">=</span> <span class="dt">Sum</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb410-3" title="3"></a>
+<a class="sourceLine" id="cb410-4" title="4"><span class="kw">instance</span> <span class="dt">Monoid</span> (<span class="dt">Product</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb410-5" title="5">  <span class="fu">mempty</span> <span class="fu">=</span> <span class="dt">Product</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb410-6" title="6"></a>
+<a class="sourceLine" id="cb410-7" title="7"><span class="kw">instance</span> <span class="dt">Monoid</span> [] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb410-8" title="8">  <span class="fu">mempty</span> <span class="fu">=</span> []</a></code></pre></div>
 <p>So, what is a monoid for a programmer? A type forms a monoid if there’s a way of combining two elements of the type together so that parenthesis don’t matter, and there’s a also an “empty element” that can be combined with things without changing them. When thought of like this, monoids come up in programming quite often!</p>
 <h3 id="why"><span class="header-section-number">7.3.4</span> Why?</h3>
 <p>What use is this <code>Monoid</code> class? Can’t we just write <code>1 + 2</code> instead of <code>Sum 1 &lt;&gt; Sum 2</code>? We can, yes, but some library functions work on all <code>Monoid</code> types.</p>
 <p>The reason we want both a neutral element and an associative binary operator is that those are the exact two things we need in order to <em>reduce</em> or <em>fold</em> multiple elements into one value. This is the job of:</p>
-<div class="sourceCode" id="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb411-1" data-line-number="1">mconcat<span class="ot"> ::</span> <span class="dt">Monoid</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb411-1" title="1"><span class="fu">mconcat</span><span class="ot"> ::</span> <span class="dt">Monoid</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> a</a></code></pre></div>
 <p>Sidenote: one way to define <code>mconcat</code> is <code>foldr (&lt;&gt;) mempty</code>. Do you remember <code>foldr</code>?</p>
 <p>Let’s look at why we need the properties of <code>Monoid</code> to implement <code>mconcat</code>. Firstly, we need <code>mempty</code> to handle empty lists:</p>
-<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb412-1" data-line-number="1">mconcat []<span class="ot"> ::</span> <span class="dt">Sum</span> <span class="dt">Int</span>          <span class="fu">==&gt;</span>  <span class="dt">Sum</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb412-1" title="1"><span class="fu">mconcat</span> []<span class="ot"> ::</span> <span class="dt">Sum</span> <span class="dt">Int</span>          <span class="fu">==&gt;</span>  <span class="dt">Sum</span> <span class="dv">0</span></a></code></pre></div>
 <p>Secondly, we need associativity to be able to reduce a list <code>[x,y,z]</code> to a unique value. If <code>&lt;&gt;</code> were not associative, we would have two possible values for <code>mconcat [x,y,z]</code>, namely <code>(x&lt;&gt;y)&lt;&gt;z</code> and <code>x&lt;&gt;(y&lt;&gt;z)</code>.</p>
 <p>The most useful <code>Monoid</code> function is <code>foldMap</code>:</p>
-<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb413-1" data-line-number="1">foldMap<span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Monoid</span> m) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m</a></code></pre></div>
+<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb413-1" title="1"><span class="fu">foldMap</span><span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Monoid</span> m) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m</a></code></pre></div>
 <p>That type signature looks scary, but concrete cases are simpler:</p>
-<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb414-1" data-line-number="1">foldMap <span class="dt">Max</span> [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Max</span> <span class="dv">4</span></a>
-<a class="sourceLine" id="cb414-2" data-line-number="2">foldMap <span class="dt">Product</span> [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Product</span> <span class="dv">8</span></a>
-<a class="sourceLine" id="cb414-3" data-line-number="3"><span class="co">-- We need the ::Int to avoid an &quot;Ambiguous type variable&quot; error when printing the result</span></a></code></pre></div>
+<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb414-1" title="1"><span class="fu">foldMap</span> <span class="dt">Max</span> [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Max</span> <span class="dv">4</span></a>
+<a class="sourceLine" id="cb414-2" title="2"><span class="fu">foldMap</span> <span class="dt">Product</span> [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Product</span> <span class="dv">8</span></a>
+<a class="sourceLine" id="cb414-3" title="3"><span class="co">-- We need the ::Int to avoid an &quot;Ambiguous type variable&quot; error when printing the result</span></a></code></pre></div>
 <p>Let’s break down that type. We know that an example of a <code>Foldable t =&gt; t a</code> type is <code>[a]</code>, so we can rewrite the type as</p>
-<div class="sourceCode" id="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb415-1" data-line-number="1"><span class="ot">foldMap&#39; ::</span> <span class="dt">Monoid</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m</a></code></pre></div>
+<div class="sourceCode" id="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb415-1" title="1"><span class="ot">foldMap&#39; ::</span> <span class="dt">Monoid</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m</a></code></pre></div>
 <p>We can build this function out of functions we already know:</p>
-<div class="sourceCode" id="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb416-1" data-line-number="1">foldMap&#39; f xs <span class="fu">=</span> mconcat (map f xs)</a></code></pre></div>
+<div class="sourceCode" id="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb416-1" title="1">foldMap&#39; f xs <span class="fu">=</span> <span class="fu">mconcat</span> (<span class="fu">map</span> f xs)</a></code></pre></div>
 <p>Oh, by the way, thanks to the <code>(Monoid a, Monoid b) =&gt; Monoid (a,b)</code> instance we can even compute the maximum and product in one pass:</p>
-<div class="sourceCode" id="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb417-1" data-line-number="1">foldMap (\x <span class="ot">-&gt;</span> (<span class="dt">Max</span> x, <span class="dt">Product</span> x)) [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  (<span class="dt">Max</span> <span class="dv">4</span>, <span class="dt">Product</span> <span class="dv">8</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb417-1" title="1"><span class="fu">foldMap</span> (\x <span class="ot">-&gt;</span> (<span class="dt">Max</span> x, <span class="dt">Product</span> x)) [<span class="dv">1</span><span class="ot">::</span><span class="dt">Int</span>,<span class="dv">4</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  (<span class="dt">Max</span> <span class="dv">4</span>, <span class="dt">Product</span> <span class="dv">8</span>)</a></code></pre></div>
 <p>Note, you don’t need to use monoids in your own code, but you’ll eventually bump into them when using Haskell libraries so it’s good to know what they are.</p>
 <h3 id="how"><span class="header-section-number">7.3.5</span> How?</h3>
 <p>Due to various historical and performance reasons, the definition of the <code>Monoid</code> and <code>Semigroup</code> classes aren’t just</p>
-<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb418-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb418-2" data-line-number="2"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb418-3" data-line-number="3"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb418-4" data-line-number="4"><span class="ot">  mempty ::</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb418-1" title="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb418-2" title="2"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb418-3" title="3"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb418-4" title="4"><span class="ot">  mempty ::</span> a</a></code></pre></div>
 <p>Although you can mostly pretend they are. The actual definitions are:</p>
-<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb419-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb419-2" data-line-number="2">  <span class="co">-- | An associative operation.</span></a>
-<a class="sourceLine" id="cb419-3" data-line-number="3"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb419-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb419-5" data-line-number="5">  <span class="co">-- Combine elements of a nonempty list with &lt;&gt;</span></a>
-<a class="sourceLine" id="cb419-6" data-line-number="6"><span class="ot">  sconcat ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb419-7" data-line-number="7">  sconcat as <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a>
-<a class="sourceLine" id="cb419-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb419-9" data-line-number="9">  <span class="co">-- Combine a value with itself using &lt;&gt;, n times</span></a>
-<a class="sourceLine" id="cb419-10" data-line-number="10"><span class="ot">  stimes ::</span> <span class="dt">Integral</span> b <span class="ot">=&gt;</span> b <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb419-11" data-line-number="11">  stimes n x <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a></code></pre></div>
-<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb420-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb420-2" data-line-number="2"><span class="ot">  mempty  ::</span> a</a>
-<a class="sourceLine" id="cb420-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb420-4" data-line-number="4"><span class="ot">  mappend ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb420-5" data-line-number="5">  mappend <span class="fu">=</span> (<span class="fu">&lt;&gt;</span>)</a>
-<a class="sourceLine" id="cb420-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb420-7" data-line-number="7">  <span class="co">-- Combine elements of a list with &lt;&gt;</span></a>
-<a class="sourceLine" id="cb420-8" data-line-number="8"><span class="ot">  mconcat ::</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb420-9" data-line-number="9">  mconcat <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a></code></pre></div>
+<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb419-1" title="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb419-2" title="2">  <span class="co">-- | An associative operation.</span></a>
+<a class="sourceLine" id="cb419-3" title="3"><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb419-4" title="4"></a>
+<a class="sourceLine" id="cb419-5" title="5">  <span class="co">-- Combine elements of a nonempty list with &lt;&gt;</span></a>
+<a class="sourceLine" id="cb419-6" title="6"><span class="ot">  sconcat ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb419-7" title="7">  sconcat as <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a>
+<a class="sourceLine" id="cb419-8" title="8"></a>
+<a class="sourceLine" id="cb419-9" title="9">  <span class="co">-- Combine a value with itself using &lt;&gt;, n times</span></a>
+<a class="sourceLine" id="cb419-10" title="10"><span class="ot">  stimes ::</span> <span class="dt">Integral</span> b <span class="ot">=&gt;</span> b <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb419-11" title="11">  stimes n x <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a></code></pre></div>
+<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb420-1" title="1"><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb420-2" title="2"><span class="ot">  mempty  ::</span> a</a>
+<a class="sourceLine" id="cb420-3" title="3"></a>
+<a class="sourceLine" id="cb420-4" title="4"><span class="ot">  mappend ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb420-5" title="5">  <span class="fu">mappend</span> <span class="fu">=</span> (<span class="fu">&lt;&gt;</span>)</a>
+<a class="sourceLine" id="cb420-6" title="6"></a>
+<a class="sourceLine" id="cb420-7" title="7">  <span class="co">-- Combine elements of a list with &lt;&gt;</span></a>
+<a class="sourceLine" id="cb420-8" title="8"><span class="ot">  mconcat ::</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb420-9" title="9">  <span class="fu">mconcat</span> <span class="fu">=</span> <span class="fu">...</span> <span class="co">-- default implementation omitted</span></a></code></pre></div>
 <p>As you can see, all the operations except <code>&lt;&gt;</code> and <code>mempty</code> have default definitions, so a normal <code>Monoid</code> instance declaration looks just like this:</p>
-<div class="sourceCode" id="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb421-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Semigroup</span> <span class="dt">MyType</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb421-2" data-line-number="2">  x <span class="fu">&lt;&gt;</span> y <span class="fu">=</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb421-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb421-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Monoid</span> <span class="dt">MyType</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb421-5" data-line-number="5">  mempty <span class="fu">=</span> <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb421-1" title="1"><span class="kw">instance</span> <span class="dt">Semigroup</span> <span class="dt">MyType</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb421-2" title="2">  x <span class="fu">&lt;&gt;</span> y <span class="fu">=</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb421-3" title="3"></a>
+<a class="sourceLine" id="cb421-4" title="4"><span class="kw">instance</span> <span class="dt">Monoid</span> <span class="dt">MyType</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb421-5" title="5">  <span class="fu">mempty</span> <span class="fu">=</span> <span class="fu">...</span></a></code></pre></div>
 <h2 id="open-and-closed-abstractions"><span class="header-section-number">7.4</span> Open and Closed Abstractions</h2>
 <p>A question novice Haskell programmers often ask (or at least should ask!) is: when should I use type classes? This section offers one answer.</p>
 <p>Let’s look at a concrete example. A vehicle can be either a car or an airplane. We can model this with algebraic datatypes (as we’ve seen earlier in this chapter), but also with type classes. Here’s the datatype version:</p>
-<div class="sourceCode" id="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb422-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Vehicle</span> <span class="fu">=</span> <span class="dt">Car</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Airplane</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb422-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb422-3" data-line-number="3"><span class="ot">sound ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb422-4" data-line-number="4">sound (<span class="dt">Car</span> _) <span class="fu">=</span> <span class="st">&quot;brum brum&quot;</span></a>
-<a class="sourceLine" id="cb422-5" data-line-number="5">sound (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="st">&quot;zooooom&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb422-1" title="1"><span class="kw">data</span> <span class="dt">Vehicle</span> <span class="fu">=</span> <span class="dt">Car</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Airplane</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb422-2" title="2"></a>
+<a class="sourceLine" id="cb422-3" title="3"><span class="ot">sound ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb422-4" title="4">sound (<span class="dt">Car</span> _) <span class="fu">=</span> <span class="st">&quot;brum brum&quot;</span></a>
+<a class="sourceLine" id="cb422-5" title="5">sound (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="st">&quot;zooooom&quot;</span></a></code></pre></div>
 <p>Here’s the class version. Note how each case gets its own datatype, which are collected together in a type class.</p>
-<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb423-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Car</span> <span class="fu">=</span> <span class="dt">Car</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb423-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Airplane</span> <span class="fu">=</span> <span class="dt">Airplane</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb423-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb423-4" data-line-number="4"><span class="kw">class</span> <span class="dt">VehicleClass</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb423-5" data-line-number="5"><span class="ot">  sound ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb423-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb423-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Car</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb423-8" data-line-number="8">  sound (<span class="dt">Car</span> _) <span class="fu">=</span> <span class="st">&quot;brum brum&quot;</span></a>
-<a class="sourceLine" id="cb423-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb423-10" data-line-number="10"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Airplane</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb423-11" data-line-number="11">  sound (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="st">&quot;zooooom&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb423-1" title="1"><span class="kw">data</span> <span class="dt">Car</span> <span class="fu">=</span> <span class="dt">Car</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb423-2" title="2"><span class="kw">data</span> <span class="dt">Airplane</span> <span class="fu">=</span> <span class="dt">Airplane</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb423-3" title="3"></a>
+<a class="sourceLine" id="cb423-4" title="4"><span class="kw">class</span> <span class="dt">VehicleClass</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb423-5" title="5"><span class="ot">  sound ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb423-6" title="6"></a>
+<a class="sourceLine" id="cb423-7" title="7"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Car</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb423-8" title="8">  sound (<span class="dt">Car</span> _) <span class="fu">=</span> <span class="st">&quot;brum brum&quot;</span></a>
+<a class="sourceLine" id="cb423-9" title="9"></a>
+<a class="sourceLine" id="cb423-10" title="10"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Airplane</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb423-11" title="11">  sound (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="st">&quot;zooooom&quot;</span></a></code></pre></div>
 <p>What is the difference between these solutions? The data-based solution is <em>closed</em>, meaning the set of cases is fixed and we can handle all of them in one place. The class-based solution is <em>open</em>, meaning we can add new cases, even in other modules.</p>
 <p>An open abstraction is nice when we want extensibility. In the class-based solution, another module could define a bike:</p>
-<div class="sourceCode" id="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb424-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Bike</span> <span class="fu">=</span> <span class="dt">Bike</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb424-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb424-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Bike</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb424-4" data-line-number="4">  sound (<span class="dt">Bike</span> _) <span class="fu">=</span> <span class="st">&quot;whirrr&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb424-1" title="1"><span class="kw">data</span> <span class="dt">Bike</span> <span class="fu">=</span> <span class="dt">Bike</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb424-2" title="2"></a>
+<a class="sourceLine" id="cb424-3" title="3"><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Bike</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb424-4" title="4">  sound (<span class="dt">Bike</span> _) <span class="fu">=</span> <span class="st">&quot;whirrr&quot;</span></a></code></pre></div>
 <p>A closed abstraction is good when we want to know that we’ve handled all cases, consider for example the function <code>canCollide</code> which checks whether two vehicles can collide:</p>
-<div class="sourceCode" id="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb425-1" data-line-number="1"><span class="ot">canCollide ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb425-2" data-line-number="2">canCollide (<span class="dt">Car</span> _)      (<span class="dt">Car</span> _)      <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb425-3" data-line-number="3">canCollide (<span class="dt">Airplane</span> _) (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb425-4" data-line-number="4">canCollide _            _            <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb425-1" title="1"><span class="ot">canCollide ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb425-2" title="2">canCollide (<span class="dt">Car</span> _)      (<span class="dt">Car</span> _)      <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb425-3" title="3">canCollide (<span class="dt">Airplane</span> _) (<span class="dt">Airplane</span> _) <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb425-4" title="4">canCollide _            _            <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <p>This would be very hard to implement reliably in the class-based solution. Consider for example how collision checks between <code>Bike</code>s and <code>Car</code>s would get handled.</p>
 <h2 id="modeling-with-languages"><span class="header-section-number">7.5</span> Modeling with Languages</h2>
 <p>Sometimes it’s useful to implement a mini programming language for describing parts of your software. The fancy term for these is an <em>Embedded Domain-Specific Language (EDSL)</em>. Haskell is well suited to modeling and interpreting languages. The expressions of the language are represented using (often recursive) algebraic data types. The language can be <em>interpreted</em> (that is, evaluated or run) by a recursive function.</p>
 <p>Here’s an example of a language for describing price computations for products in a web shop.</p>
-<div class="sourceCode" id="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb426-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Discount</span> <span class="fu">=</span> <span class="dt">DiscountPercent</span> <span class="dt">Int</span>         <span class="co">-- A percentage discount</span></a>
-<a class="sourceLine" id="cb426-2" data-line-number="2">              <span class="fu">|</span> <span class="dt">DiscountConstant</span> <span class="dt">Int</span>        <span class="co">-- A constant discount</span></a>
-<a class="sourceLine" id="cb426-3" data-line-number="3">              <span class="fu">|</span> <span class="dt">MinimumPrice</span> <span class="dt">Int</span>            <span class="co">-- Set a minimum price</span></a>
-<a class="sourceLine" id="cb426-4" data-line-number="4">              <span class="fu">|</span> <span class="dt">ForCustomer</span> <span class="dt">String</span> <span class="dt">Discount</span> <span class="co">-- Discounts can be conditional</span></a>
-<a class="sourceLine" id="cb426-5" data-line-number="5">              <span class="fu">|</span> <span class="dt">Many</span> [<span class="dt">Discount</span>]             <span class="co">-- Apply a number of discounts in row</span></a></code></pre></div>
+<div class="sourceCode" id="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb426-1" title="1"><span class="kw">data</span> <span class="dt">Discount</span> <span class="fu">=</span> <span class="dt">DiscountPercent</span> <span class="dt">Int</span>         <span class="co">-- A percentage discount</span></a>
+<a class="sourceLine" id="cb426-2" title="2">              <span class="fu">|</span> <span class="dt">DiscountConstant</span> <span class="dt">Int</span>        <span class="co">-- A constant discount</span></a>
+<a class="sourceLine" id="cb426-3" title="3">              <span class="fu">|</span> <span class="dt">MinimumPrice</span> <span class="dt">Int</span>            <span class="co">-- Set a minimum price</span></a>
+<a class="sourceLine" id="cb426-4" title="4">              <span class="fu">|</span> <span class="dt">ForCustomer</span> <span class="dt">String</span> <span class="dt">Discount</span> <span class="co">-- Discounts can be conditional</span></a>
+<a class="sourceLine" id="cb426-5" title="5">              <span class="fu">|</span> <span class="dt">Many</span> [<span class="dt">Discount</span>]             <span class="co">-- Apply a number of discounts in row</span></a></code></pre></div>
 <p>The language is interpreted by the function <code>applyDiscount</code> that takes a customer name, a price, a discount, and returns a price.</p>
-<div class="sourceCode" id="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb427-1" data-line-number="1"><span class="ot">applyDiscount ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Discount</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb427-2" data-line-number="2">applyDiscount _        price (<span class="dt">DiscountPercent</span> percent) <span class="fu">=</span> price <span class="fu">-</span> (price <span class="fu">*</span> percent) <span class="ot">`div`</span> <span class="dv">100</span></a>
-<a class="sourceLine" id="cb427-3" data-line-number="3">applyDiscount _        price (<span class="dt">DiscountConstant</span> discount) <span class="fu">=</span> price <span class="fu">-</span> discount</a>
-<a class="sourceLine" id="cb427-4" data-line-number="4">applyDiscount _        price (<span class="dt">MinimumPrice</span> minPrice) <span class="fu">=</span> max price minPrice</a>
-<a class="sourceLine" id="cb427-5" data-line-number="5">applyDiscount customer price (<span class="dt">ForCustomer</span> target discount)</a>
-<a class="sourceLine" id="cb427-6" data-line-number="6">    <span class="fu">|</span> customer <span class="fu">==</span> target  <span class="fu">=</span> applyDiscount customer price discount</a>
-<a class="sourceLine" id="cb427-7" data-line-number="7">    <span class="fu">|</span> otherwise           <span class="fu">=</span> price</a>
-<a class="sourceLine" id="cb427-8" data-line-number="8">applyDiscount customer price (<span class="dt">Many</span> discounts) <span class="fu">=</span> go price discounts</a>
-<a class="sourceLine" id="cb427-9" data-line-number="9">  <span class="kw">where</span> go p [] <span class="fu">=</span> p</a>
-<a class="sourceLine" id="cb427-10" data-line-number="10">        go p (d<span class="fu">:</span>ds) <span class="fu">=</span> go (applyDiscount customer p d) ds</a></code></pre></div>
+<div class="sourceCode" id="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb427-1" title="1"><span class="ot">applyDiscount ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Discount</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb427-2" title="2">applyDiscount _        price (<span class="dt">DiscountPercent</span> percent) <span class="fu">=</span> price <span class="fu">-</span> (price <span class="fu">*</span> percent) <span class="ot">`div`</span> <span class="dv">100</span></a>
+<a class="sourceLine" id="cb427-3" title="3">applyDiscount _        price (<span class="dt">DiscountConstant</span> discount) <span class="fu">=</span> price <span class="fu">-</span> discount</a>
+<a class="sourceLine" id="cb427-4" title="4">applyDiscount _        price (<span class="dt">MinimumPrice</span> minPrice) <span class="fu">=</span> <span class="fu">max</span> price minPrice</a>
+<a class="sourceLine" id="cb427-5" title="5">applyDiscount customer price (<span class="dt">ForCustomer</span> target discount)</a>
+<a class="sourceLine" id="cb427-6" title="6">    <span class="fu">|</span> customer <span class="fu">==</span> target  <span class="fu">=</span> applyDiscount customer price discount</a>
+<a class="sourceLine" id="cb427-7" title="7">    <span class="fu">|</span> <span class="fu">otherwise</span>           <span class="fu">=</span> price</a>
+<a class="sourceLine" id="cb427-8" title="8">applyDiscount customer price (<span class="dt">Many</span> discounts) <span class="fu">=</span> go price discounts</a>
+<a class="sourceLine" id="cb427-9" title="9">  <span class="kw">where</span> go p [] <span class="fu">=</span> p</a>
+<a class="sourceLine" id="cb427-10" title="10">        go p (d<span class="fu">:</span>ds) <span class="fu">=</span> go (applyDiscount customer p d) ds</a></code></pre></div>
 <p>Here we apply a discount chain of -50%, -$30 with a minimum price of $35:</p>
-<div class="sourceCode" id="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb428-1" data-line-number="1">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">DiscountPercent</span> <span class="dv">50</span>)</a>
-<a class="sourceLine" id="cb428-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">60</span></a>
-<a class="sourceLine" id="cb428-3" data-line-number="3">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">60</span> (<span class="dt">DiscountConstant</span> <span class="dv">30</span>)</a>
-<a class="sourceLine" id="cb428-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">30</span></a>
-<a class="sourceLine" id="cb428-5" data-line-number="5">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span> (<span class="dt">MinimumPrice</span> <span class="dv">35</span>)</a>
-<a class="sourceLine" id="cb428-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dv">35</span></a>
-<a class="sourceLine" id="cb428-7" data-line-number="7">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">Many</span> [<span class="dt">DiscountPercent</span> <span class="dv">50</span>, <span class="dt">DiscountConstant</span> <span class="dv">30</span>, <span class="dt">MinimumPrice</span> <span class="dv">35</span>])</a>
-<a class="sourceLine" id="cb428-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dv">35</span></a></code></pre></div>
+<div class="sourceCode" id="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb428-1" title="1">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">DiscountPercent</span> <span class="dv">50</span>)</a>
+<a class="sourceLine" id="cb428-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">60</span></a>
+<a class="sourceLine" id="cb428-3" title="3">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">60</span> (<span class="dt">DiscountConstant</span> <span class="dv">30</span>)</a>
+<a class="sourceLine" id="cb428-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">30</span></a>
+<a class="sourceLine" id="cb428-5" title="5">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span> (<span class="dt">MinimumPrice</span> <span class="dv">35</span>)</a>
+<a class="sourceLine" id="cb428-6" title="6">  <span class="fu">==&gt;</span> <span class="dv">35</span></a>
+<a class="sourceLine" id="cb428-7" title="7">applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">Many</span> [<span class="dt">DiscountPercent</span> <span class="dv">50</span>, <span class="dt">DiscountConstant</span> <span class="dv">30</span>, <span class="dt">MinimumPrice</span> <span class="dv">35</span>])</a>
+<a class="sourceLine" id="cb428-8" title="8">  <span class="fu">==&gt;</span> <span class="dv">35</span></a></code></pre></div>
 <p>Here we have different discounts for Ssarah and Yvonne:</p>
-<div class="sourceCode" id="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb429-1" data-line-number="1">applyDiscount <span class="st">&quot;Yvonne&quot;</span> <span class="dv">100</span> (<span class="dt">Many</span> [<span class="dt">ForCustomer</span> <span class="st">&quot;Yvonne&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">10</span>), <span class="dt">ForCustomer</span> <span class="st">&quot;Ssarah&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">20</span>)])</a>
-<a class="sourceLine" id="cb429-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dv">90</span></a>
-<a class="sourceLine" id="cb429-3" data-line-number="3">applyDiscount <span class="st">&quot;Ssarah&quot;</span> <span class="dv">100</span> (<span class="dt">Many</span> [<span class="dt">ForCustomer</span> <span class="st">&quot;Yvonne&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">10</span>), <span class="dt">ForCustomer</span> <span class="st">&quot;Ssarah&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">20</span>)])</a>
-<a class="sourceLine" id="cb429-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">80</span></a></code></pre></div>
+<div class="sourceCode" id="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb429-1" title="1">applyDiscount <span class="st">&quot;Yvonne&quot;</span> <span class="dv">100</span> (<span class="dt">Many</span> [<span class="dt">ForCustomer</span> <span class="st">&quot;Yvonne&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">10</span>), <span class="dt">ForCustomer</span> <span class="st">&quot;Ssarah&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">20</span>)])</a>
+<a class="sourceLine" id="cb429-2" title="2">  <span class="fu">==&gt;</span> <span class="dv">90</span></a>
+<a class="sourceLine" id="cb429-3" title="3">applyDiscount <span class="st">&quot;Ssarah&quot;</span> <span class="dv">100</span> (<span class="dt">Many</span> [<span class="dt">ForCustomer</span> <span class="st">&quot;Yvonne&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">10</span>), <span class="dt">ForCustomer</span> <span class="st">&quot;Ssarah&quot;</span> (<span class="dt">DiscountConstant</span> <span class="dv">20</span>)])</a>
+<a class="sourceLine" id="cb429-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">80</span></a></code></pre></div>
 <p>As you can see, even a simple <code>Discount</code> type can generate complex behaviours because it is self-referential (recursive). Using <code>Discount</code> we are able to represent the discount logic of our webshop as <em>data</em> instead of writing code.</p>
 <p>There are multiple reasons for representing logic as data instead of code. Unlike code, data can easily be stored in a file or database, or even transmitted over the network. We can also use the same data for multiple purposes, for exaple we could visualize the discount chains in an administration user interface.</p>
 <!-- ## TODO: Quiz -->
@@ -3839,103 +3837,103 @@ If I define an instance for <code>Num</code>, I also get an instance for <code>F
 <h2 id="a-taste-of-io"><span class="header-section-number">8.1</span> A Taste of IO</h2>
 <p>This course has been centered around pure functional programming. We’ve done lots of arithmetic, reversed lists, worked with binary trees, but so far we haven’t been able to affect the world outside our GHCi.</p>
 <p>Things like reading input, writing to a file, or talking over the network are <em>side effects</em>. Side effects can’t be represented with pure functional code. A function like</p>
-<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb430-1" data-line-number="1"><span class="ot">readInputFromTheUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb430-1" title="1"><span class="ot">readInputFromTheUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a></code></pre></div>
 <p>can’t be pure, because if it were, <code>readInputFromUser &quot;What is your name?&quot;</code> would always have to return the same result. However, representing side-effects and impurity in a pure language <em>is</em> possible. There are many ways of doing it, and the Haskell way is to use <em>Monads</em>.</p>
 <p>Monads are reputedly difficult to understand. That is probably because they are so abstract. I think it’s best to focus on practical and concrete cases first. Here’s a taste of the <code>IO</code> Monad, which you can use for all sorts of side effects in Haskell.</p>
 <p>Let’s start!</p>
-<div class="sourceCode" id="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb431-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t getLine</a>
-<a class="sourceLine" id="cb431-2" data-line-number="2">getLine<span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb431-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> line <span class="ot">&lt;-</span> getLine</a></code></pre></div>
+<div class="sourceCode" id="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb431-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb431-2" title="2"><span class="fu">getLine</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb431-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> line <span class="ot">&lt;-</span> <span class="fu">getLine</span></a></code></pre></div>
 <pre><code>another line</code></pre>
-<div class="sourceCode" id="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb433-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t line</a>
-<a class="sourceLine" id="cb433-2" data-line-number="2"><span class="ot">line ::</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb433-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> line</a>
-<a class="sourceLine" id="cb433-4" data-line-number="4"><span class="st">&quot;another line&quot;</span></a>
-<a class="sourceLine" id="cb433-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> reverse line</a>
-<a class="sourceLine" id="cb433-6" data-line-number="6"><span class="st">&quot;enil rehtona&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb433-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t line</a>
+<a class="sourceLine" id="cb433-2" title="2"><span class="ot">line ::</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb433-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> line</a>
+<a class="sourceLine" id="cb433-4" title="4"><span class="st">&quot;another line&quot;</span></a>
+<a class="sourceLine" id="cb433-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">reverse</span> line</a>
+<a class="sourceLine" id="cb433-6" title="6"><span class="st">&quot;enil rehtona&quot;</span></a></code></pre></div>
 <p>What we’ve seen here is the <em>IO action</em> <code>getLine</code>. It has type <code>IO String</code>. This means that GHCi can <em>execute</em> the action to produce a value of type <code>String</code>. When we enter <code>line &lt;- getLine</code> into GHCi, we mean:</p>
 <blockquote>
 <p>Execute the IO action <code>getLine</code>, and give the result the name <code>line</code>.</p>
 </blockquote>
 <p>After we’ve received <code>line</code>, it’s a pure <code>String</code> value and we can work with it normally.</p>
 <p>Some IO actions take parameters. For example <code>putStrLn :: String -&gt; IO ()</code> takes a <code>String</code> and returns an <code>IO</code> action that prints that string. The <code>()</code> type is a special type that only has one value, <code>()</code>. In this case <code>IO ()</code> means that this IO always produces the same empty value <code>()</code>. You can run IO actions by just</p>
-<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb434-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t putStrLn</a>
-<a class="sourceLine" id="cb434-2" data-line-number="2">putStrLn<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb434-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t putStrLn <span class="st">&quot;hello&quot;</span></a>
-<a class="sourceLine" id="cb434-4" data-line-number="4">putStrLn <span class="st">&quot;hello&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb434-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> val <span class="ot">&lt;-</span> putStrLn <span class="st">&quot;hello&quot;</span></a>
-<a class="sourceLine" id="cb434-6" data-line-number="6">hello</a>
-<a class="sourceLine" id="cb434-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> val</a>
-<a class="sourceLine" id="cb434-8" data-line-number="8">()</a></code></pre></div>
+<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb434-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">putStrLn</span></a>
+<a class="sourceLine" id="cb434-2" title="2"><span class="fu">putStrLn</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb434-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></a>
+<a class="sourceLine" id="cb434-4" title="4"><span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb434-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> val <span class="ot">&lt;-</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></a>
+<a class="sourceLine" id="cb434-6" title="6">hello</a>
+<a class="sourceLine" id="cb434-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> val</a>
+<a class="sourceLine" id="cb434-8" title="8">()</a></code></pre></div>
 <p>If you don’t need the return value of an IO action, you can run it <em>in GHCi</em> without the <code>&lt;-</code>:</p>
-<div class="sourceCode" id="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb435-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> putStrLn <span class="st">&quot;hello&quot;</span></a>
-<a class="sourceLine" id="cb435-2" data-line-number="2">hello</a></code></pre></div>
+<div class="sourceCode" id="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb435-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></a>
+<a class="sourceLine" id="cb435-2" title="2">hello</a></code></pre></div>
 <p>You can build your own IO actions by combining other actions with <em>do-notation</em>. A <code>do</code> block lists IO actions that are executed in order.</p>
-<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb436-1" data-line-number="1"><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb436-2" data-line-number="2">printTwoThings <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb436-3" data-line-number="3">  putStrLn <span class="st">&quot;Hello!&quot;</span></a>
-<a class="sourceLine" id="cb436-4" data-line-number="4">  putStrLn <span class="st">&quot;How are you?&quot;</span></a>
-<a class="sourceLine" id="cb436-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb436-6" data-line-number="6"><span class="ot">greet ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb436-7" data-line-number="7">greet <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb436-8" data-line-number="8">  putStrLn <span class="st">&quot;What&#39;s your name?&quot;</span></a>
-<a class="sourceLine" id="cb436-9" data-line-number="9">  name <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb436-10" data-line-number="10">  putStrLn (<span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name)</a></code></pre></div>
-<div class="sourceCode" id="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb437-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printTwoThings</a>
-<a class="sourceLine" id="cb437-2" data-line-number="2"><span class="dt">Hello</span><span class="fu">!</span></a>
-<a class="sourceLine" id="cb437-3" data-line-number="3"><span class="dt">How</span> are you<span class="fu">?</span></a>
-<a class="sourceLine" id="cb437-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet</a>
-<a class="sourceLine" id="cb437-5" data-line-number="5"><span class="dt">What&#39;s</span> your name<span class="fu">?</span></a>
-<a class="sourceLine" id="cb437-6" data-line-number="6"><span class="dt">Seraphim</span></a>
-<a class="sourceLine" id="cb437-7" data-line-number="7"><span class="dt">Hello</span>, <span class="dt">Seraphim</span></a></code></pre></div>
+<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb436-1" title="1"><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb436-2" title="2">printTwoThings <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb436-3" title="3">  <span class="fu">putStrLn</span> <span class="st">&quot;Hello!&quot;</span></a>
+<a class="sourceLine" id="cb436-4" title="4">  <span class="fu">putStrLn</span> <span class="st">&quot;How are you?&quot;</span></a>
+<a class="sourceLine" id="cb436-5" title="5"></a>
+<a class="sourceLine" id="cb436-6" title="6"><span class="ot">greet ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb436-7" title="7">greet <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb436-8" title="8">  <span class="fu">putStrLn</span> <span class="st">&quot;What&#39;s your name?&quot;</span></a>
+<a class="sourceLine" id="cb436-9" title="9">  name <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb436-10" title="10">  <span class="fu">putStrLn</span> (<span class="st">&quot;Hello, &quot;</span> <span class="fu">++</span> name)</a></code></pre></div>
+<div class="sourceCode" id="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb437-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printTwoThings</a>
+<a class="sourceLine" id="cb437-2" title="2"><span class="dt">Hello</span><span class="fu">!</span></a>
+<a class="sourceLine" id="cb437-3" title="3"><span class="dt">How</span> are you<span class="fu">?</span></a>
+<a class="sourceLine" id="cb437-4" title="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> greet</a>
+<a class="sourceLine" id="cb437-5" title="5"><span class="dt">What&#39;s</span> your name<span class="fu">?</span></a>
+<a class="sourceLine" id="cb437-6" title="6"><span class="dt">Seraphim</span></a>
+<a class="sourceLine" id="cb437-7" title="7"><span class="dt">Hello</span>, <span class="dt">Seraphim</span></a></code></pre></div>
 <h3 id="what-about-purity"><span class="header-section-number">8.1.1</span> What About Purity?</h3>
 <p>It feels as if we can just do side effects where ever we want with these IO actions. However, it’s important to remember the distinction between <em>defining</em> an IO action and <em>executing</em> it.</p>
 <p>Let’s try to print while mapping over a list</p>
-<div class="sourceCode" id="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb438-1" data-line-number="1"><span class="ot">printAndIncrement ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb438-2" data-line-number="2">printAndIncrement x <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb438-3" data-line-number="3">  <span class="kw">where</span> action <span class="fu">=</span> putStrLn <span class="st">&quot;got a number!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb439"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb439-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> map printAndIncrement [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb439-2" data-line-number="2">[<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb438-1" title="1"><span class="ot">printAndIncrement ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb438-2" title="2">printAndIncrement x <span class="fu">=</span> x<span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb438-3" title="3">  <span class="kw">where</span> action <span class="fu">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;got a number!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb439"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb439-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> printAndIncrement [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb439-2" title="2">[<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a></code></pre></div>
 <p>This didn’t print anything, because even though we defined our <code>action</code>, it wasn’t given to GHCi for execution. Because <code>printAndIncrement</code> returns an <code>Int</code>, it can’t return an action. Ok, let’s try another approach:</p>
-<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb440-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> length (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
-<a class="sourceLine" id="cb440-2" data-line-number="2"><span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb440-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">length</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
+<a class="sourceLine" id="cb440-2" title="2"><span class="dv">2</span></a></code></pre></div>
 <p>That didn’t print anything either! Let’s see why:</p>
-<div class="sourceCode" id="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb441-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>]</a>
-<a class="sourceLine" id="cb441-2" data-line-number="2">map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>]<span class="ot"> ::</span> [<span class="dt">IO</span> ()]</a>
-<a class="sourceLine" id="cb441-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t length (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
-<a class="sourceLine" id="cb441-4" data-line-number="4">length (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])<span class="ot"> ::</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb441-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>]</a>
+<a class="sourceLine" id="cb441-2" title="2"><span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>]<span class="ot"> ::</span> [<span class="dt">IO</span> ()]</a>
+<a class="sourceLine" id="cb441-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">length</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
+<a class="sourceLine" id="cb441-4" title="4"><span class="fu">length</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])<span class="ot"> ::</span> <span class="dt">Int</span></a></code></pre></div>
 <p>We generated a list of IO actions and computed the value of the list. Defining IO actions is pure, it’s <em>running</em> them that causes side effects. Since the type of our expression was <code>Int</code>, no <code>IO</code> actions could land in GHCi and be executed.</p>
 <p>If we instead return an IO action, it does get run:</p>
-<div class="sourceCode" id="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb442-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t head (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
-<a class="sourceLine" id="cb442-2" data-line-number="2">head (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])<span class="ot"> ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb442-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> head (map putStrLn [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
-<a class="sourceLine" id="cb442-4" data-line-number="4">string1</a></code></pre></div>
+<div class="sourceCode" id="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb442-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">head</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
+<a class="sourceLine" id="cb442-2" title="2"><span class="fu">head</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])<span class="ot"> ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb442-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> (<span class="fu">map</span> <span class="fu">putStrLn</span> [<span class="st">&quot;string1&quot;</span>,<span class="st">&quot;string2&quot;</span>])</a>
+<a class="sourceLine" id="cb442-4" title="4">string1</a></code></pre></div>
 <p>Here too, the code that produces the action <code>putStrLn &quot;string1&quot;</code> is pure, it’s only after the IO action is executed by GHCi that we see the printed string. And as you can see, the other IO action, <code>putStrLn &quot;string2&quot;</code>, never got run.</p>
 <p>If this feels complicated, don’t worry. We’ll get back to this on part 2 of the course.</p>
 <h3 id="what-about-haskell-programs"><span class="header-section-number">8.1.2</span> What About Haskell Programs?</h3>
 <p>We know that GHCi can run IO actions. What about actual Haskell programs? The way Haskell programs work is that the IO action called <code>main</code> gets executed when the program is run. Recall our example program from Lecture 1.</p>
-<div class="sourceCode" id="cb443"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb443-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb443-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb443-3" data-line-number="3"><span class="co">-- The golden ratio</span></a>
-<a class="sourceLine" id="cb443-4" data-line-number="4"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb443-5" data-line-number="5">phi <span class="fu">=</span> (sqrt <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb443-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb443-7" data-line-number="7"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb443-8" data-line-number="8">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb443-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb443-10" data-line-number="10">f x <span class="fu">=</span> polynomial (polynomial x)</a>
-<a class="sourceLine" id="cb443-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb443-12" data-line-number="12">main <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb443-13" data-line-number="13">  print (polynomial phi)</a>
-<a class="sourceLine" id="cb443-14" data-line-number="14">  print (f phi)</a></code></pre></div>
+<div class="sourceCode" id="cb443"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb443-1" title="1"><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb443-2" title="2"></a>
+<a class="sourceLine" id="cb443-3" title="3"><span class="co">-- The golden ratio</span></a>
+<a class="sourceLine" id="cb443-4" title="4"><span class="ot">phi ::</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb443-5" title="5">phi <span class="fu">=</span> (<span class="fu">sqrt</span> <span class="dv">5</span> <span class="fu">+</span> <span class="dv">1</span>) <span class="fu">/</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb443-6" title="6"></a>
+<a class="sourceLine" id="cb443-7" title="7"><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb443-8" title="8">polynomial x <span class="fu">=</span> x<span class="fu">^</span><span class="dv">2</span> <span class="fu">-</span> x <span class="fu">-</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb443-9" title="9"></a>
+<a class="sourceLine" id="cb443-10" title="10">f x <span class="fu">=</span> polynomial (polynomial x)</a>
+<a class="sourceLine" id="cb443-11" title="11"></a>
+<a class="sourceLine" id="cb443-12" title="12">main <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb443-13" title="13">  <span class="fu">print</span> (polynomial phi)</a>
+<a class="sourceLine" id="cb443-14" title="14">  <span class="fu">print</span> (f phi)</a></code></pre></div>
 <p>Here we see some pure code and a <code>main</code> IO action that prints two things (<code>print</code> is just <code>putStrLn</code> combined with <code>show</code>).</p>
 <p>We can place this code in a file called <code>Gold.hs</code>, compile it into an executable, and run it:</p>
-<div class="sourceCode" id="cb444"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb444-1" data-line-number="1">$ <span class="ex">ghc</span> -main-is Gold Gold.hs</a>
-<a class="sourceLine" id="cb444-2" data-line-number="2">[<span class="ex">1</span> of 1] Compiling Gold             ( Gold.hs, Gold.o )</a>
-<a class="sourceLine" id="cb444-3" data-line-number="3"><span class="ex">Linking</span> Gold ...</a>
-<a class="sourceLine" id="cb444-4" data-line-number="4">$ <span class="ex">./Gold</span></a>
-<a class="sourceLine" id="cb444-5" data-line-number="5"><span class="ex">0.0</span></a>
-<a class="sourceLine" id="cb444-6" data-line-number="6"><span class="ex">-1.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb444"><pre class="sourceCode sh"><code class="sourceCode bash"><a class="sourceLine" id="cb444-1" title="1">$ <span class="ex">ghc</span> -main-is Gold Gold.hs</a>
+<a class="sourceLine" id="cb444-2" title="2">[<span class="ex">1</span> of 1] Compiling Gold             ( Gold.hs, Gold.o )</a>
+<a class="sourceLine" id="cb444-3" title="3"><span class="ex">Linking</span> Gold ...</a>
+<a class="sourceLine" id="cb444-4" title="4">$ <span class="ex">./Gold</span></a>
+<a class="sourceLine" id="cb444-5" title="5"><span class="ex">0.0</span></a>
+<a class="sourceLine" id="cb444-6" title="6"><span class="ex">-1.0</span></a></code></pre></div>
 <h2 id="summary"><span class="header-section-number">8.2</span> Summary</h2>
 <p>So far, we’ve learned about Haskell’s syntax and types, quite a bit of functional programming and about some language features like type classes.</p>
 <p>We’ve also seen some type-oriented programming, and even gotten a taste of I/O in Haskell.</p>
diff --git a/part2.html b/part2.html
index ceefb52..8da61a3 100644
--- a/part2.html
+++ b/part2.html
@@ -14,7 +14,7 @@
   <style type="text/css">
 a.sourceLine { display: inline-block; line-height: 1.25; }
 a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
-a.sourceLine:empty { height: 1.2em; position: absolute; }
+a.sourceLine:empty { height: 1.2em; }
 .sourceCode { overflow: visible; }
 code.sourceCode { white-space: pre; position: relative; }
 div.sourceCode { margin: 1em 0; }
@@ -27,13 +27,11 @@ code.sourceCode { white-space: pre-wrap; }
 a.sourceLine { text-indent: -1em; padding-left: 1em; }
 }
 pre.numberSource a.sourceLine
-  { position: relative; }
-pre.numberSource a.sourceLine:empty
-  { position: absolute; }
+  { position: relative; left: -4em; }
 pre.numberSource a.sourceLine::before
-  { content: attr(data-line-number);
-    position: absolute; left: -5em; text-align: right; vertical-align: baseline;
-    border: none; pointer-events: all;
+  { content: attr(title);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; pointer-events: all; display: inline-block;
     -webkit-touch-callout: none; -webkit-user-select: none;
     -khtml-user-select: none; -moz-user-select: none;
     -ms-user-select: none; user-select: none;
@@ -281,26 +279,26 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 </tbody>
 </table>
 <p>There’s one more powerful mechanism for creating more types: <em>Algebraic datatypes</em> (ADTs). Some examples include:</p>
-<div class="sourceCode" id="cb1"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb1-1" data-line-number="1"><span class="co">-- Enumeration types</span></a>
-<a class="sourceLine" id="cb1-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb1-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Red</span> <span class="fu">|</span> <span class="dt">Green</span> <span class="fu">|</span> <span class="dt">Blue</span></a>
-<a class="sourceLine" id="cb1-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb1-5" data-line-number="5"><span class="co">-- Record types that contain fields</span></a>
-<a class="sourceLine" id="cb1-6" data-line-number="6"><span class="kw">data</span> <span class="dt">Vector2d</span> <span class="fu">=</span> <span class="dt">MakeVector</span> <span class="dt">Double</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb1-7" data-line-number="7"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span> <span class="dt">Int</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb1-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb1-9" data-line-number="9"><span class="co">-- Parameterized types. Note the type parameter `a`</span></a>
-<a class="sourceLine" id="cb1-10" data-line-number="10"><span class="kw">data</span> <span class="dt">PairOf</span> a <span class="fu">=</span> <span class="dt">TwoValues</span> a a</a>
-<a class="sourceLine" id="cb1-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb1-12" data-line-number="12"><span class="co">-- Recursive types</span></a>
-<a class="sourceLine" id="cb1-13" data-line-number="13"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
-<a class="sourceLine" id="cb1-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb1-15" data-line-number="15"><span class="co">-- Complex types which combine many of these features</span></a>
-<a class="sourceLine" id="cb1-16" data-line-number="16"><span class="kw">data</span> <span class="dt">Maybe</span> a <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> a</a>
-<a class="sourceLine" id="cb1-17" data-line-number="17"><span class="kw">data</span> <span class="dt">Either</span> a b <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Right</span> b</a>
-<a class="sourceLine" id="cb1-18" data-line-number="18"><span class="kw">data</span> <span class="dt">List</span> a <span class="fu">=</span> <span class="dt">Nil</span> <span class="fu">|</span> <span class="dt">Cons</span> a (<span class="dt">List</span> a)             <span class="co">-- This is equivalent to the built-in [a] type</span></a>
-<a class="sourceLine" id="cb1-19" data-line-number="19"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> a <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
-<a class="sourceLine" id="cb1-20" data-line-number="20"><span class="kw">data</span> <span class="dt">MultiTree</span> a <span class="fu">=</span> <span class="dt">MultiTree</span> a [<span class="dt">MultiTree</span> a]     <span class="co">-- Note the list</span></a></code></pre></div>
+<div class="sourceCode" id="cb1"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb1-1" title="1"><span class="co">-- Enumeration types</span></a>
+<a class="sourceLine" id="cb1-2" title="2"><span class="kw">data</span> <span class="dt">Bool</span> <span class="fu">=</span> <span class="dt">True</span> <span class="fu">|</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb1-3" title="3"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">Red</span> <span class="fu">|</span> <span class="dt">Green</span> <span class="fu">|</span> <span class="dt">Blue</span></a>
+<a class="sourceLine" id="cb1-4" title="4"></a>
+<a class="sourceLine" id="cb1-5" title="5"><span class="co">-- Record types that contain fields</span></a>
+<a class="sourceLine" id="cb1-6" title="6"><span class="kw">data</span> <span class="dt">Vector2d</span> <span class="fu">=</span> <span class="dt">MakeVector</span> <span class="dt">Double</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb1-7" title="7"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span> <span class="dt">Int</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb1-8" title="8"></a>
+<a class="sourceLine" id="cb1-9" title="9"><span class="co">-- Parameterized types. Note the type parameter `a`</span></a>
+<a class="sourceLine" id="cb1-10" title="10"><span class="kw">data</span> <span class="dt">PairOf</span> a <span class="fu">=</span> <span class="dt">TwoValues</span> a a</a>
+<a class="sourceLine" id="cb1-11" title="11"></a>
+<a class="sourceLine" id="cb1-12" title="12"><span class="co">-- Recursive types</span></a>
+<a class="sourceLine" id="cb1-13" title="13"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Empty</span> <span class="fu">|</span> <span class="dt">Node</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
+<a class="sourceLine" id="cb1-14" title="14"></a>
+<a class="sourceLine" id="cb1-15" title="15"><span class="co">-- Complex types which combine many of these features</span></a>
+<a class="sourceLine" id="cb1-16" title="16"><span class="kw">data</span> <span class="dt">Maybe</span> a <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu">|</span> <span class="dt">Just</span> a</a>
+<a class="sourceLine" id="cb1-17" title="17"><span class="kw">data</span> <span class="dt">Either</span> a b <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Right</span> b</a>
+<a class="sourceLine" id="cb1-18" title="18"><span class="kw">data</span> <span class="dt">List</span> a <span class="fu">=</span> <span class="dt">Nil</span> <span class="fu">|</span> <span class="dt">Cons</span> a (<span class="dt">List</span> a)             <span class="co">-- This is equivalent to the built-in [a] type</span></a>
+<a class="sourceLine" id="cb1-19" title="19"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> a <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
+<a class="sourceLine" id="cb1-20" title="20"><span class="kw">data</span> <span class="dt">MultiTree</span> a <span class="fu">=</span> <span class="dt">MultiTree</span> a [<span class="dt">MultiTree</span> a]     <span class="co">-- Note the list</span></a></code></pre></div>
 <p>Values of these types include:</p>
 <table>
 <thead>
@@ -362,9 +360,9 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 </table>
 <p>You can combine parameterized types in complex ways, for example with something like <code>Either [String-&gt;String] (Maybe String, Int)</code>.</p>
 <p>The names of concrete types start with capital letters. Lowercase letters are used for <em>type variables</em> which indicate <em>parametric polymorphism</em>: functions and values that can have multiple types. Here are some examples of polymorphic function types:</p>
-<div class="sourceCode" id="cb2"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb2-1" data-line-number="1">[a] <span class="ot">-&gt;</span> [a]    <span class="co">-- function from list of any type, to list of the same type</span></a>
-<a class="sourceLine" id="cb2-2" data-line-number="2">[a] <span class="ot">-&gt;</span> a      <span class="co">-- function from list of any type, to the element type</span></a>
-<a class="sourceLine" id="cb2-3" data-line-number="3">(a,b) <span class="ot">-&gt;</span> [a]  <span class="co">-- function from tuple to list</span></a></code></pre></div>
+<div class="sourceCode" id="cb2"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb2-1" title="1">[a] <span class="ot">-&gt;</span> [a]    <span class="co">-- function from list of any type, to list of the same type</span></a>
+<a class="sourceLine" id="cb2-2" title="2">[a] <span class="ot">-&gt;</span> a      <span class="co">-- function from list of any type, to the element type</span></a>
+<a class="sourceLine" id="cb2-3" title="3">(a,b) <span class="ot">-&gt;</span> [a]  <span class="co">-- function from tuple to list</span></a></code></pre></div>
 <h3 id="more-about-lists"><span class="header-section-number">9.1.1</span> More About Lists</h3>
 <p>List literals can be written in using the familiar <code>[x,y,z]</code> syntax. However, that notation is just a shorthand as lists are actually built up of the list constructors <code>[]</code> and <code>(:)</code>. These constructors are also used when pattern matching lists. Here are some examples of lists:</p>
 <table>
@@ -463,162 +461,162 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 <p>Just one more note on the syntax. Recall that <code>(:)</code> associates to the right, e.g. <code>True:False:[]</code> is the same as <code>True:(False:[])</code>. (In fact, <code>(True:False):[]</code> is not even a list, because <code>True:False</code> attempts to add <code>True</code> in front of <code>False</code> which is not a list.)</p>
 <h2 id="functions"><span class="header-section-number">9.2</span> Functions</h2>
 <p>The basic form of function definition is:</p>
-<div class="sourceCode" id="cb3"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb3-1" data-line-number="1"><span class="ot">functionName ::</span> argumentType <span class="ot">-&gt;</span> returnType</a>
-<a class="sourceLine" id="cb3-2" data-line-number="2">functionName argument <span class="fu">=</span> returnValue</a></code></pre></div>
+<div class="sourceCode" id="cb3"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb3-1" title="1"><span class="ot">functionName ::</span> argumentType <span class="ot">-&gt;</span> returnType</a>
+<a class="sourceLine" id="cb3-2" title="2">functionName argument <span class="fu">=</span> returnValue</a></code></pre></div>
 <p>For example:</p>
-<div class="sourceCode" id="cb4"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb4-1" data-line-number="1"><span class="ot">repeatString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb4-2" data-line-number="2">repeatString s <span class="fu">=</span> s <span class="fu">++</span> s</a></code></pre></div>
+<div class="sourceCode" id="cb4"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb4-1" title="1"><span class="ot">repeatString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb4-2" title="2">repeatString s <span class="fu">=</span> s <span class="fu">++</span> s</a></code></pre></div>
 <p>Functions taking multiple arguments are defined in a similar manner. Note how the type of a multi-argument function looks like.</p>
-<div class="sourceCode" id="cb5"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb5-1" data-line-number="1"><span class="ot">surroundString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb5-2" data-line-number="2">surroundString around s <span class="fu">=</span> around <span class="fu">++</span> s <span class="fu">++</span> around</a></code></pre></div>
+<div class="sourceCode" id="cb5"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb5-1" title="1"><span class="ot">surroundString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb5-2" title="2">surroundString around s <span class="fu">=</span> around <span class="fu">++</span> s <span class="fu">++</span> around</a></code></pre></div>
 <p>Functions can be polymorphic, can take multiple arguments, and can even take functions as arguments. Here are more examples:</p>
-<div class="sourceCode" id="cb6"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb6-1" data-line-number="1">id<span class="ot"> ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb6-2" data-line-number="2">id x <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb6-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb6-4" data-line-number="4">const<span class="ot"> ::</span> a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb6-5" data-line-number="5">const x y <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb6-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb6-7" data-line-number="7">flip<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> c</a>
-<a class="sourceLine" id="cb6-8" data-line-number="8">flip f x y <span class="fu">=</span> f y x</a></code></pre></div>
+<div class="sourceCode" id="cb6"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb6-1" title="1"><span class="fu">id</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb6-2" title="2"><span class="fu">id</span> x <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb6-3" title="3"></a>
+<a class="sourceLine" id="cb6-4" title="4"><span class="fu">const</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb6-5" title="5"><span class="fu">const</span> x y <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb6-6" title="6"></a>
+<a class="sourceLine" id="cb6-7" title="7"><span class="fu">flip</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> c</a>
+<a class="sourceLine" id="cb6-8" title="8"><span class="fu">flip</span> f x y <span class="fu">=</span> f y x</a></code></pre></div>
 <p>More sophisticated functions can be defined using <em>pattern matching</em>. We can pattern match on the <em>constructors</em> of algebraic datatypes like <code>Maybe</code>, and also lists with the constructors <code>[]</code> and <code>(:)</code>.</p>
-<div class="sourceCode" id="cb7"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb7-1" data-line-number="1"><span class="ot">swap ::</span> (a,b) <span class="ot">-&gt;</span> (b,a)</a>
-<a class="sourceLine" id="cb7-2" data-line-number="2">swap (x,y) <span class="fu">=</span> (y,x)</a>
-<a class="sourceLine" id="cb7-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb7-4" data-line-number="4">maybe<span class="ot"> ::</span> b <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> b</a>
-<a class="sourceLine" id="cb7-5" data-line-number="5">maybe def _ <span class="dt">Nothing</span>  <span class="fu">=</span> def</a>
-<a class="sourceLine" id="cb7-6" data-line-number="6">maybe _   f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a>
-<a class="sourceLine" id="cb7-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb7-8" data-line-number="8"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb7-9" data-line-number="9">safeHead []    <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb7-10" data-line-number="10">safeHead (x<span class="fu">:</span>_) <span class="fu">=</span> <span class="dt">Just</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb7"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb7-1" title="1"><span class="ot">swap ::</span> (a,b) <span class="ot">-&gt;</span> (b,a)</a>
+<a class="sourceLine" id="cb7-2" title="2">swap (x,y) <span class="fu">=</span> (y,x)</a>
+<a class="sourceLine" id="cb7-3" title="3"></a>
+<a class="sourceLine" id="cb7-4" title="4"><span class="fu">maybe</span><span class="ot"> ::</span> b <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> b</a>
+<a class="sourceLine" id="cb7-5" title="5"><span class="fu">maybe</span> def _ <span class="dt">Nothing</span>  <span class="fu">=</span> def</a>
+<a class="sourceLine" id="cb7-6" title="6"><span class="fu">maybe</span> _   f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a>
+<a class="sourceLine" id="cb7-7" title="7"></a>
+<a class="sourceLine" id="cb7-8" title="8"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb7-9" title="9">safeHead []    <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb7-10" title="10">safeHead (x<span class="fu">:</span>_) <span class="fu">=</span> <span class="dt">Just</span> x</a></code></pre></div>
 <p>Yet more sophistication can be achieved with <em>guards</em>. Guards let you define a function case-by-case based on tests of type <code>Bool</code>. Guards are useful in situations where pattern matching can’t be used. Of course, guards can also be combined with pattern matching:</p>
-<div class="sourceCode" id="cb8"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb8-1" data-line-number="1"><span class="ot">myAbs ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb8-2" data-line-number="2">myAbs x</a>
-<a class="sourceLine" id="cb8-3" data-line-number="3">  <span class="fu">|</span> x <span class="fu">&lt;</span> <span class="dv">0</span>     <span class="fu">=</span> <span class="fu">-</span>x</a>
-<a class="sourceLine" id="cb8-4" data-line-number="4">  <span class="fu">|</span> otherwise <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb8-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb8-6" data-line-number="6"><span class="ot">safeDiv ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb8-7" data-line-number="7">safeDiv x y</a>
-<a class="sourceLine" id="cb8-8" data-line-number="8">  <span class="fu">|</span> y <span class="fu">==</span> <span class="dv">0</span>    <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb8-9" data-line-number="9">  <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">Just</span> (x <span class="fu">/</span> y)</a>
-<a class="sourceLine" id="cb8-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb8-11" data-line-number="11"><span class="ot">buy ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb8-12" data-line-number="12">buy <span class="st">&quot;Banana&quot;</span> money</a>
-<a class="sourceLine" id="cb8-13" data-line-number="13">  <span class="fu">|</span> money <span class="fu">&lt;</span> <span class="fl">3.2</span>   <span class="fu">=</span> <span class="st">&quot;You don&#39;t have enough money for a banana&quot;</span></a>
-<a class="sourceLine" id="cb8-14" data-line-number="14">  <span class="fu">|</span> otherwise     <span class="fu">=</span> <span class="st">&quot;You bought a banana&quot;</span></a>
-<a class="sourceLine" id="cb8-15" data-line-number="15">buy product  _    <span class="fu">=</span> <span class="st">&quot;No such product: &quot;</span> <span class="fu">++</span> product</a></code></pre></div>
+<div class="sourceCode" id="cb8"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb8-1" title="1"><span class="ot">myAbs ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb8-2" title="2">myAbs x</a>
+<a class="sourceLine" id="cb8-3" title="3">  <span class="fu">|</span> x <span class="fu">&lt;</span> <span class="dv">0</span>     <span class="fu">=</span> <span class="fu">-</span>x</a>
+<a class="sourceLine" id="cb8-4" title="4">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb8-5" title="5"></a>
+<a class="sourceLine" id="cb8-6" title="6"><span class="ot">safeDiv ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb8-7" title="7">safeDiv x y</a>
+<a class="sourceLine" id="cb8-8" title="8">  <span class="fu">|</span> y <span class="fu">==</span> <span class="dv">0</span>    <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb8-9" title="9">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">Just</span> (x <span class="fu">/</span> y)</a>
+<a class="sourceLine" id="cb8-10" title="10"></a>
+<a class="sourceLine" id="cb8-11" title="11"><span class="ot">buy ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb8-12" title="12">buy <span class="st">&quot;Banana&quot;</span> money</a>
+<a class="sourceLine" id="cb8-13" title="13">  <span class="fu">|</span> money <span class="fu">&lt;</span> <span class="fl">3.2</span>   <span class="fu">=</span> <span class="st">&quot;You don&#39;t have enough money for a banana&quot;</span></a>
+<a class="sourceLine" id="cb8-14" title="14">  <span class="fu">|</span> <span class="fu">otherwise</span>     <span class="fu">=</span> <span class="st">&quot;You bought a banana&quot;</span></a>
+<a class="sourceLine" id="cb8-15" title="15">buy <span class="fu">product</span>  _    <span class="fu">=</span> <span class="st">&quot;No such product: &quot;</span> <span class="fu">++</span> <span class="fu">product</span></a></code></pre></div>
 <p><em>Case expressions</em> let us pattern match inside functions. They are useful in situations where the result of one function depends on the result of another and we want to match the pattern on the output of the other function:</p>
-<div class="sourceCode" id="cb9"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb9-1" data-line-number="1"><span class="ot">divDefault ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb9-2" data-line-number="2">divDefault x y def <span class="fu">=</span> <span class="kw">case</span> safeDiv x y <span class="kw">of</span></a>
-<a class="sourceLine" id="cb9-3" data-line-number="3">  <span class="dt">Nothing</span> <span class="ot">-&gt;</span> def</a>
-<a class="sourceLine" id="cb9-4" data-line-number="4">  <span class="dt">Just</span> w  <span class="ot">-&gt;</span> w</a></code></pre></div>
+<div class="sourceCode" id="cb9"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb9-1" title="1"><span class="ot">divDefault ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb9-2" title="2">divDefault x y def <span class="fu">=</span> <span class="kw">case</span> safeDiv x y <span class="kw">of</span></a>
+<a class="sourceLine" id="cb9-3" title="3">  <span class="dt">Nothing</span> <span class="ot">-&gt;</span> def</a>
+<a class="sourceLine" id="cb9-4" title="4">  <span class="dt">Just</span> w  <span class="ot">-&gt;</span> w</a></code></pre></div>
 <p>Let-expressions enable <em>local definitions</em>. Where-clauses work similarly to <code>let</code>s. For example:</p>
-<div class="sourceCode" id="cb10"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb10-1" data-line-number="1"><span class="ot">circleArea ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb10-2" data-line-number="2">circleArea r <span class="fu">=</span> <span class="kw">let</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb10-3" data-line-number="3">                   square x <span class="fu">=</span> x <span class="fu">*</span> x</a>
-<a class="sourceLine" id="cb10-4" data-line-number="4">               <span class="kw">in</span> pi <span class="fu">*</span> square r</a>
-<a class="sourceLine" id="cb10-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb10-6" data-line-number="6"><span class="ot">circleArea&#39; ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb10-7" data-line-number="7">circleArea&#39; r <span class="fu">=</span> pi <span class="fu">*</span> square r</a>
-<a class="sourceLine" id="cb10-8" data-line-number="8">    <span class="kw">where</span> pi <span class="fu">=</span> <span class="fl">3.1415926</span></a>
-<a class="sourceLine" id="cb10-9" data-line-number="9">          square x <span class="fu">=</span> x <span class="fu">*</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb10"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb10-1" title="1"><span class="ot">circleArea ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb10-2" title="2">circleArea r <span class="fu">=</span> <span class="kw">let</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb10-3" title="3">                   square x <span class="fu">=</span> x <span class="fu">*</span> x</a>
+<a class="sourceLine" id="cb10-4" title="4">               <span class="kw">in</span> <span class="fu">pi</span> <span class="fu">*</span> square r</a>
+<a class="sourceLine" id="cb10-5" title="5"></a>
+<a class="sourceLine" id="cb10-6" title="6"><span class="ot">circleArea&#39; ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb10-7" title="7">circleArea&#39; r <span class="fu">=</span> <span class="fu">pi</span> <span class="fu">*</span> square r</a>
+<a class="sourceLine" id="cb10-8" title="8">    <span class="kw">where</span> <span class="fu">pi</span> <span class="fu">=</span> <span class="fl">3.1415926</span></a>
+<a class="sourceLine" id="cb10-9" title="9">          square x <span class="fu">=</span> x <span class="fu">*</span> x</a></code></pre></div>
 <p><em>Lambda expressions</em> are another occasionally useful syntax for defining functions. Lambda expressions represent anonymous (unnamed) functions. They can be used for defining local functions that are typically used only once.</p>
-<div class="sourceCode" id="cb11"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb11-1" data-line-number="1"><span class="ot">incrementAll ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb11-2" data-line-number="2">incrementAll xs <span class="fu">=</span> map (\x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) xs</a></code></pre></div>
+<div class="sourceCode" id="cb11"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb11-1" title="1"><span class="ot">incrementAll ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb11-2" title="2">incrementAll xs <span class="fu">=</span> <span class="fu">map</span> (\x <span class="ot">-&gt;</span> x <span class="fu">+</span> <span class="dv">1</span>) xs</a></code></pre></div>
 <p>Note that <code>f x = y</code> is the same thing as <code>f = \x -&gt; y</code>.</p>
 <p>Finally, binary operators have <em>sections</em>. Sections are partially applied operators. The section of an operator is obtained by writing the operator and one of its arguments in parentheses. For example, <code>(*2)</code> multiplies its argument by <code>2</code> from the right, e.g. <code>(*2) 5 ==&gt; 5 * 2</code>. A fractional number (e.g. a <code>Double</code>) can be inverted with the section <code>(1/)</code>, e.g. <code>(1/) 2 ==&gt; 0.5</code>.</p>
-<div class="sourceCode" id="cb12"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb12-1" data-line-number="1"><span class="ot">incrementAll&#39; ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb12-2" data-line-number="2">incrementAll&#39; xs <span class="fu">=</span> map (<span class="fu">+</span><span class="dv">1</span>) xs</a></code></pre></div>
+<div class="sourceCode" id="cb12"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb12-1" title="1"><span class="ot">incrementAll&#39; ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb12-2" title="2">incrementAll&#39; xs <span class="fu">=</span> <span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) xs</a></code></pre></div>
 <h2 id="functional-programming"><span class="header-section-number">9.3</span> Functional Programming</h2>
 <p>Haskell is a functional programming language, which means that functions can be passed in as arguments and returned from functions. As a programming paradigm, functional programming aims to build programs by combining simple functions together to form larger and larger ones.</p>
 <p>The most often presented example of functional programming is functional list manipulation using <em>higher-order functions</em> (functions that take functions as arguments) like <code>map</code> and <code>filter</code>. Here’s one example from part 1:</p>
-<div class="sourceCode" id="cb13"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb13-1" data-line-number="1"><span class="co">-- a predicate that checks if a string is a palindrome</span></a>
-<a class="sourceLine" id="cb13-2" data-line-number="2"><span class="ot">palindrome ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb13-3" data-line-number="3">palindrome str <span class="fu">=</span> str <span class="fu">==</span> reverse str</a>
-<a class="sourceLine" id="cb13-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb13-5" data-line-number="5"><span class="co">-- palindromes n takes all numbers from 1 to n, converts them to</span></a>
-<a class="sourceLine" id="cb13-6" data-line-number="6"><span class="co">-- strings using show, and keeps only palindromes</span></a>
-<a class="sourceLine" id="cb13-7" data-line-number="7"><span class="ot">palindromes ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb13-8" data-line-number="8">palindromes n <span class="fu">=</span> filter palindrome (map show [<span class="dv">1</span><span class="fu">..</span>n])</a></code></pre></div>
-<div class="sourceCode" id="cb14"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb14-1" data-line-number="1">palindromes <span class="dv">150</span></a>
-<a class="sourceLine" id="cb14-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;1&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;3&quot;</span>,<span class="st">&quot;4&quot;</span>,<span class="st">&quot;5&quot;</span>,<span class="st">&quot;6&quot;</span>,<span class="st">&quot;7&quot;</span>,<span class="st">&quot;8&quot;</span>,<span class="st">&quot;9&quot;</span>,</a>
-<a class="sourceLine" id="cb14-3" data-line-number="3">       <span class="st">&quot;11&quot;</span>,<span class="st">&quot;22&quot;</span>,<span class="st">&quot;33&quot;</span>,<span class="st">&quot;44&quot;</span>,<span class="st">&quot;55&quot;</span>,<span class="st">&quot;66&quot;</span>,<span class="st">&quot;77&quot;</span>,<span class="st">&quot;88&quot;</span>,<span class="st">&quot;99&quot;</span>,</a>
-<a class="sourceLine" id="cb14-4" data-line-number="4">       <span class="st">&quot;101&quot;</span>,<span class="st">&quot;111&quot;</span>,<span class="st">&quot;121&quot;</span>,<span class="st">&quot;131&quot;</span>,<span class="st">&quot;141&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb13"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb13-1" title="1"><span class="co">-- a predicate that checks if a string is a palindrome</span></a>
+<a class="sourceLine" id="cb13-2" title="2"><span class="ot">palindrome ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb13-3" title="3">palindrome str <span class="fu">=</span> str <span class="fu">==</span> <span class="fu">reverse</span> str</a>
+<a class="sourceLine" id="cb13-4" title="4"></a>
+<a class="sourceLine" id="cb13-5" title="5"><span class="co">-- palindromes n takes all numbers from 1 to n, converts them to</span></a>
+<a class="sourceLine" id="cb13-6" title="6"><span class="co">-- strings using show, and keeps only palindromes</span></a>
+<a class="sourceLine" id="cb13-7" title="7"><span class="ot">palindromes ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb13-8" title="8">palindromes n <span class="fu">=</span> <span class="fu">filter</span> palindrome (<span class="fu">map</span> <span class="fu">show</span> [<span class="dv">1</span><span class="fu">..</span>n])</a></code></pre></div>
+<div class="sourceCode" id="cb14"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb14-1" title="1">palindromes <span class="dv">150</span></a>
+<a class="sourceLine" id="cb14-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;1&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;3&quot;</span>,<span class="st">&quot;4&quot;</span>,<span class="st">&quot;5&quot;</span>,<span class="st">&quot;6&quot;</span>,<span class="st">&quot;7&quot;</span>,<span class="st">&quot;8&quot;</span>,<span class="st">&quot;9&quot;</span>,</a>
+<a class="sourceLine" id="cb14-3" title="3">       <span class="st">&quot;11&quot;</span>,<span class="st">&quot;22&quot;</span>,<span class="st">&quot;33&quot;</span>,<span class="st">&quot;44&quot;</span>,<span class="st">&quot;55&quot;</span>,<span class="st">&quot;66&quot;</span>,<span class="st">&quot;77&quot;</span>,<span class="st">&quot;88&quot;</span>,<span class="st">&quot;99&quot;</span>,</a>
+<a class="sourceLine" id="cb14-4" title="4">       <span class="st">&quot;101&quot;</span>,<span class="st">&quot;111&quot;</span>,<span class="st">&quot;121&quot;</span>,<span class="st">&quot;131&quot;</span>,<span class="st">&quot;141&quot;</span>]</a></code></pre></div>
 <p>We also encountered other functional programming patterns in part 1, like <em>partial application</em>:</p>
-<div class="sourceCode" id="cb15"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb15-1" data-line-number="1">map (take <span class="dv">3</span>) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>,<span class="dv">0</span>]]</a>
-<a class="sourceLine" id="cb15-2" data-line-number="2">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>]]</a></code></pre></div>
+<div class="sourceCode" id="cb15"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb15-1" title="1"><span class="fu">map</span> (<span class="fu">take</span> <span class="dv">3</span>) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>,<span class="dv">0</span>]]</a>
+<a class="sourceLine" id="cb15-2" title="2">  <span class="fu">==&gt;</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>]]</a></code></pre></div>
 <p>Also, <em>function composition</em>:</p>
-<div class="sourceCode" id="cb16"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb16-1" data-line-number="1">(map reverse <span class="fu">.</span> filter (<span class="fu">/=</span><span class="st">&quot;Smith&quot;</span>)) [<span class="st">&quot;Jones&quot;</span>,<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;White&quot;</span>]</a>
-<a class="sourceLine" id="cb16-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;senoJ&quot;</span>,<span class="st">&quot;etihW&quot;</span>]</a>
-<a class="sourceLine" id="cb16-3" data-line-number="3">map (negate <span class="fu">.</span> sum) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">5</span>]]</a>
-<a class="sourceLine" id="cb16-4" data-line-number="4">  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">6</span>,<span class="fu">-</span><span class="dv">5</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb16"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb16-1" title="1">(<span class="fu">map</span> <span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">filter</span> (<span class="fu">/=</span><span class="st">&quot;Smith&quot;</span>)) [<span class="st">&quot;Jones&quot;</span>,<span class="st">&quot;Smith&quot;</span>,<span class="st">&quot;White&quot;</span>]</a>
+<a class="sourceLine" id="cb16-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;senoJ&quot;</span>,<span class="st">&quot;etihW&quot;</span>]</a>
+<a class="sourceLine" id="cb16-3" title="3"><span class="fu">map</span> (<span class="fu">negate</span> <span class="fu">.</span> <span class="fu">sum</span>) [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">5</span>]]</a>
+<a class="sourceLine" id="cb16-4" title="4">  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">6</span>,<span class="fu">-</span><span class="dv">5</span>]</a></code></pre></div>
 <p>And finally, <em>folds</em>:</p>
-<div class="sourceCode" id="cb17"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb17-1" data-line-number="1">foldr (<span class="fu">*</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]  <span class="fu">==&gt;</span> <span class="dv">24</span></a>
-<a class="sourceLine" id="cb17-2" data-line-number="2">foldr max <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">7</span>]  <span class="fu">==&gt;</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb17-3" data-line-number="3">foldr (<span class="fu">++</span>) <span class="st">&quot;&quot;</span> [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;de&quot;</span>,<span class="st">&quot;f&quot;</span>] <span class="fu">==&gt;</span> <span class="st">&quot;abcdef&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb17"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb17-1" title="1"><span class="fu">foldr</span> (<span class="fu">*</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]  <span class="fu">==&gt;</span> <span class="dv">24</span></a>
+<a class="sourceLine" id="cb17-2" title="2"><span class="fu">foldr</span> <span class="fu">max</span> <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">3</span>,<span class="dv">7</span>]  <span class="fu">==&gt;</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb17-3" title="3"><span class="fu">foldr</span> (<span class="fu">++</span>) <span class="st">&quot;&quot;</span> [<span class="st">&quot;abc&quot;</span>,<span class="st">&quot;de&quot;</span>,<span class="st">&quot;f&quot;</span>] <span class="fu">==&gt;</span> <span class="st">&quot;abcdef&quot;</span></a></code></pre></div>
 <h2 id="recursion"><span class="header-section-number">9.4</span> Recursion</h2>
 <p>To implement a function that uses repetition in Haskell, you need recursion. Haskell has no loops like other programming languages. Here are some simple recursive functions in Haskell:</p>
-<div class="sourceCode" id="cb18"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb18-1" data-line-number="1"><span class="ot">repeatString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb18-2" data-line-number="2">repeatString <span class="dv">0</span> s <span class="fu">=</span> <span class="st">&quot;&quot;</span></a>
-<a class="sourceLine" id="cb18-3" data-line-number="3">repeatString n s <span class="fu">=</span> s <span class="fu">++</span> repeatString (n<span class="fu">-</span><span class="dv">1</span>) s</a>
-<a class="sourceLine" id="cb18-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb18-5" data-line-number="5"><span class="ot">times ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb18-6" data-line-number="6">times <span class="dv">0</span> n <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb18-7" data-line-number="7">times <span class="dv">1</span> n <span class="fu">=</span> n</a>
-<a class="sourceLine" id="cb18-8" data-line-number="8">times m n <span class="fu">=</span> n <span class="fu">+</span> times (m <span class="fu">-</span> <span class="dv">1</span>) n</a>
-<a class="sourceLine" id="cb18-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb18-10" data-line-number="10"><span class="ot">safeLast ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb18-11" data-line-number="11">safeLast []     <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb18-12" data-line-number="12">safeLast [x]    <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb18-13" data-line-number="13">safeLast (x<span class="fu">:</span>xs) <span class="fu">=</span> safeLast xs</a></code></pre></div>
+<div class="sourceCode" id="cb18"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb18-1" title="1"><span class="ot">repeatString ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb18-2" title="2">repeatString <span class="dv">0</span> s <span class="fu">=</span> <span class="st">&quot;&quot;</span></a>
+<a class="sourceLine" id="cb18-3" title="3">repeatString n s <span class="fu">=</span> s <span class="fu">++</span> repeatString (n<span class="fu">-</span><span class="dv">1</span>) s</a>
+<a class="sourceLine" id="cb18-4" title="4"></a>
+<a class="sourceLine" id="cb18-5" title="5"><span class="ot">times ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb18-6" title="6">times <span class="dv">0</span> n <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb18-7" title="7">times <span class="dv">1</span> n <span class="fu">=</span> n</a>
+<a class="sourceLine" id="cb18-8" title="8">times m n <span class="fu">=</span> n <span class="fu">+</span> times (m <span class="fu">-</span> <span class="dv">1</span>) n</a>
+<a class="sourceLine" id="cb18-9" title="9"></a>
+<a class="sourceLine" id="cb18-10" title="10"><span class="ot">safeLast ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb18-11" title="11">safeLast []     <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb18-12" title="12">safeLast [x]    <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb18-13" title="13">safeLast (x<span class="fu">:</span>xs) <span class="fu">=</span> safeLast xs</a></code></pre></div>
 <p>To consume or produce a list you often need recursion. Here are the implementations of <code>map</code> and <code>filter</code> as examples of recursive list processing:</p>
-<div class="sourceCode" id="cb19"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb19-1" data-line-number="1">map<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb19-2" data-line-number="2">map _ []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb19-3" data-line-number="3">map f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> map f xs</a>
-<a class="sourceLine" id="cb19-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb19-5" data-line-number="5">filter<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb19-6" data-line-number="6">filter _    []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb19-7" data-line-number="7">filter pred (x<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb19-8" data-line-number="8">  <span class="fu">|</span> pred x         <span class="fu">=</span> x <span class="fu">:</span> filter pred xs</a>
-<a class="sourceLine" id="cb19-9" data-line-number="9">  <span class="fu">|</span> otherwise      <span class="fu">=</span> filter pred xs</a></code></pre></div>
+<div class="sourceCode" id="cb19"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb19-1" title="1"><span class="fu">map</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb19-2" title="2"><span class="fu">map</span> _ []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb19-3" title="3"><span class="fu">map</span> f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> <span class="fu">map</span> f xs</a>
+<a class="sourceLine" id="cb19-4" title="4"></a>
+<a class="sourceLine" id="cb19-5" title="5"><span class="fu">filter</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb19-6" title="6"><span class="fu">filter</span> _    []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb19-7" title="7"><span class="fu">filter</span> <span class="fu">pred</span> (x<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb19-8" title="8">  <span class="fu">|</span> <span class="fu">pred</span> x         <span class="fu">=</span> x <span class="fu">:</span> <span class="fu">filter</span> <span class="fu">pred</span> xs</a>
+<a class="sourceLine" id="cb19-9" title="9">  <span class="fu">|</span> <span class="fu">otherwise</span>      <span class="fu">=</span> <span class="fu">filter</span> <span class="fu">pred</span> xs</a></code></pre></div>
 <p>Sometimes, a recursive helper function is needed in case you need to keep track of multiple pieces of data.</p>
-<div class="sourceCode" id="cb20"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb20-1" data-line-number="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb20-2" data-line-number="2">sumNumbers xs <span class="fu">=</span> go <span class="dv">0</span> xs</a>
-<a class="sourceLine" id="cb20-3" data-line-number="3">  <span class="kw">where</span> go sum [] <span class="fu">=</span> sum</a>
-<a class="sourceLine" id="cb20-4" data-line-number="4">        go sum (x<span class="fu">:</span>xs) <span class="fu">=</span> go (sum<span class="fu">+</span>x) xs</a></code></pre></div>
+<div class="sourceCode" id="cb20"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb20-1" title="1"><span class="ot">sumNumbers ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb20-2" title="2">sumNumbers xs <span class="fu">=</span> go <span class="dv">0</span> xs</a>
+<a class="sourceLine" id="cb20-3" title="3">  <span class="kw">where</span> go <span class="fu">sum</span> [] <span class="fu">=</span> <span class="fu">sum</span></a>
+<a class="sourceLine" id="cb20-4" title="4">        go <span class="fu">sum</span> (x<span class="fu">:</span>xs) <span class="fu">=</span> go (<span class="fu">sum+</span>x) xs</a></code></pre></div>
 <p>Here’s a final example utilizing guards, pattern matching, a helper function and recursion:</p>
-<div class="sourceCode" id="cb21"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb21-1" data-line-number="1"><span class="co">-- split a string into pieces at the given character</span></a>
-<a class="sourceLine" id="cb21-2" data-line-number="2"><span class="ot">mySplit ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb21-3" data-line-number="3">mySplit c xs <span class="fu">=</span> helper [] xs</a>
-<a class="sourceLine" id="cb21-4" data-line-number="4">  <span class="kw">where</span> helper piece [] <span class="fu">=</span> [piece]</a>
-<a class="sourceLine" id="cb21-5" data-line-number="5">        helper piece (y<span class="fu">:</span>ys)</a>
-<a class="sourceLine" id="cb21-6" data-line-number="6">          <span class="fu">|</span> c <span class="fu">==</span> y    <span class="fu">=</span> piece <span class="fu">:</span> helper [] ys</a>
-<a class="sourceLine" id="cb21-7" data-line-number="7">          <span class="fu">|</span> otherwise <span class="fu">=</span> helper (piece<span class="fu">++</span>[y]) ys</a></code></pre></div>
-<div class="sourceCode" id="cb22"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb22-1" data-line-number="1">mySplit <span class="ch">&#39;-&#39;</span> <span class="st">&quot;a-bcd-ef&quot;</span>  <span class="fu">==&gt;</span>  [<span class="st">&quot;a&quot;</span>,<span class="st">&quot;bcd&quot;</span>,<span class="st">&quot;ef&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb21"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb21-1" title="1"><span class="co">-- split a string into pieces at the given character</span></a>
+<a class="sourceLine" id="cb21-2" title="2"><span class="ot">mySplit ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb21-3" title="3">mySplit c xs <span class="fu">=</span> helper [] xs</a>
+<a class="sourceLine" id="cb21-4" title="4">  <span class="kw">where</span> helper piece [] <span class="fu">=</span> [piece]</a>
+<a class="sourceLine" id="cb21-5" title="5">        helper piece (y<span class="fu">:</span>ys)</a>
+<a class="sourceLine" id="cb21-6" title="6">          <span class="fu">|</span> c <span class="fu">==</span> y    <span class="fu">=</span> piece <span class="fu">:</span> helper [] ys</a>
+<a class="sourceLine" id="cb21-7" title="7">          <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> helper (piece<span class="fu">++</span>[y]) ys</a></code></pre></div>
+<div class="sourceCode" id="cb22"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb22-1" title="1">mySplit <span class="ch">&#39;-&#39;</span> <span class="st">&quot;a-bcd-ef&quot;</span>  <span class="fu">==&gt;</span>  [<span class="st">&quot;a&quot;</span>,<span class="st">&quot;bcd&quot;</span>,<span class="st">&quot;ef&quot;</span>]</a></code></pre></div>
 <h2 id="type-classes"><span class="header-section-number">9.5</span> Type Classes</h2>
 <p>The following functions are <em>parametrically polymorphic</em>:</p>
-<div class="sourceCode" id="cb23"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb23-1" data-line-number="1">id<span class="ot"> ::</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb23-2" data-line-number="2">id x <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb23-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb23-4" data-line-number="4">head<span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb23-5" data-line-number="5">head (x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb23-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb23-7" data-line-number="7">fst<span class="ot"> ::</span> (a,b) <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb23-8" data-line-number="8">fst (x,y) <span class="fu">=</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb23"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb23-1" title="1"><span class="fu">id</span><span class="ot"> ::</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb23-2" title="2"><span class="fu">id</span> x <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb23-3" title="3"></a>
+<a class="sourceLine" id="cb23-4" title="4"><span class="fu">head</span><span class="ot"> ::</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb23-5" title="5"><span class="fu">head</span> (x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb23-6" title="6"></a>
+<a class="sourceLine" id="cb23-7" title="7"><span class="fu">fst</span><span class="ot"> ::</span> (a,b) <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb23-8" title="8"><span class="fu">fst</span> (x,y) <span class="fu">=</span> x</a></code></pre></div>
 <p>Parametrically polymorphic functions always work the same way, no matter what types we’re working with. This means that we can’t define a special implementation of <code>id</code> just for the <code>Int</code> type, or <code>fst</code> for the type <code>(Bool, String)</code>.</p>
 <p>By contrast, <em>ad hoc polymorphism</em> allows different types to have different implementations of the same function. Ad hoc polymorphism in Haskell can be achieved by defining a <em>type class</em> and then declaring <em>instances</em> of that type class for various types. Ad hoc polymorphism is a handy way for expressing a common set of operations, even when the implementation of the operations depends on the type they’re acting on.</p>
 <p>Functions that use ad hoc polymorphism have a <em>class constraint</em> in their types. Here are some examples:</p>
-<div class="sourceCode" id="cb24"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb24-1" data-line-number="1">negate<span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb24-2" data-line-number="2"><span class="ot">(==) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb24-3" data-line-number="3">sort<span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb24"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb24-1" title="1"><span class="fu">negate</span><span class="ot"> ::</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb24-2" title="2"><span class="ot">(==) ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb24-3" title="3"><span class="fu">sort</span><span class="ot"> ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>A type like <code>Num a =&gt; a -&gt; a</code> means: for any type <code>X</code> that’s a member of the <code>Num</code> class, this function has type <code>X -&gt; X</code>. In other words, we can invoke <code>negate</code> on any number type, but not on other types:</p>
-<div class="sourceCode" id="cb25"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb25-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> negate <span class="dv">1</span></a>
-<a class="sourceLine" id="cb25-2" data-line-number="2"><span class="fu">-</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb25-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> negate <span class="fl">1.0</span></a>
-<a class="sourceLine" id="cb25-4" data-line-number="4"><span class="fu">-</span><span class="fl">1.0</span></a>
-<a class="sourceLine" id="cb25-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> negate <span class="dt">True</span></a>
-<a class="sourceLine" id="cb25-6" data-line-number="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">3</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb25-7" data-line-number="7">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Num</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘negate’</a></code></pre></div>
+<div class="sourceCode" id="cb25"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb25-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">negate</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb25-2" title="2"><span class="fu">-</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb25-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">negate</span> <span class="fl">1.0</span></a>
+<a class="sourceLine" id="cb25-4" title="4"><span class="fu">-</span><span class="fl">1.0</span></a>
+<a class="sourceLine" id="cb25-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">negate</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb25-6" title="6"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">3</span><span class="fu">:</span><span class="dv">1</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb25-7" title="7">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Num</span> <span class="dt">Bool</span>) arising from a use <span class="kw">of</span> ‘negate’</a></code></pre></div>
 <p>Here’s a summary of some useful type classes from the standard library.</p>
 <ul>
 <li>Comparison
@@ -639,61 +637,61 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 </ul></li>
 </ul>
 <p>Sometimes, multiple class constraints are needed. For instance here:</p>
-<div class="sourceCode" id="cb26"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb26-1" data-line-number="1"><span class="ot">sumTwoSmallest ::</span> (<span class="dt">Num</span> a, <span class="dt">Ord</span> a) <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb26-2" data-line-number="2">sumTwoSmallest xs <span class="fu">=</span> <span class="kw">let</span> (a<span class="fu">:</span>b<span class="fu">:</span>_) <span class="fu">=</span> sort xs</a>
-<a class="sourceLine" id="cb26-3" data-line-number="3">                    <span class="kw">in</span> a<span class="fu">+</span>b</a></code></pre></div>
+<div class="sourceCode" id="cb26"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb26-1" title="1"><span class="ot">sumTwoSmallest ::</span> (<span class="dt">Num</span> a, <span class="dt">Ord</span> a) <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb26-2" title="2">sumTwoSmallest xs <span class="fu">=</span> <span class="kw">let</span> (a<span class="fu">:</span>b<span class="fu">:</span>_) <span class="fu">=</span> <span class="fu">sort</span> xs</a>
+<a class="sourceLine" id="cb26-3" title="3">                    <span class="kw">in</span> a<span class="fu">+</span>b</a></code></pre></div>
 <p>Now that we’ve seen some classes and types, let’s look at the syntax of declaring classes and instances. Here are two class definitions:</p>
-<div class="sourceCode" id="cb27"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb27-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Sized</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb27-2" data-line-number="2"><span class="ot">  empty ::</span> a        <span class="co">-- a thing with size 0</span></a>
-<a class="sourceLine" id="cb27-3" data-line-number="3"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb27-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb27-5" data-line-number="5"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb27-6" data-line-number="6"><span class="ot">  (==) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb27"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb27-1" title="1"><span class="kw">class</span> <span class="dt">Sized</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb27-2" title="2"><span class="ot">  empty ::</span> a        <span class="co">-- a thing with size 0</span></a>
+<a class="sourceLine" id="cb27-3" title="3"><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb27-4" title="4"></a>
+<a class="sourceLine" id="cb27-5" title="5"><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb27-6" title="6"><span class="ot">  (==) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>Consider the following data structures:</p>
-<div class="sourceCode" id="cb28"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb28-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Numbers</span> <span class="fu">=</span> <span class="dt">None</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Two</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb28-2" data-line-number="2"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Nil</span> <span class="fu">|</span> <span class="dt">ListNode</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
-<a class="sourceLine" id="cb28-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a></code></pre></div>
+<div class="sourceCode" id="cb28"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb28-1" title="1"><span class="kw">data</span> <span class="dt">Numbers</span> <span class="fu">=</span> <span class="dt">None</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Two</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb28-2" title="2"><span class="kw">data</span> <span class="dt">IntList</span> <span class="fu">=</span> <span class="dt">Nil</span> <span class="fu">|</span> <span class="dt">ListNode</span> <span class="dt">Int</span> <span class="dt">IntList</span></a>
+<a class="sourceLine" id="cb28-3" title="3"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a></code></pre></div>
 <p>All of these have sizes that we can count, but we need to perform the operation differently:</p>
-<div class="sourceCode" id="cb29"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb29-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Sized</span> <span class="dt">Numbers</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb29-2" data-line-number="2">  empty <span class="fu">=</span> <span class="dt">None</span></a>
-<a class="sourceLine" id="cb29-3" data-line-number="3">  size <span class="dt">None</span>      <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb29-4" data-line-number="4">  size (<span class="dt">One</span> _)   <span class="fu">=</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb29-5" data-line-number="5">  size (<span class="dt">Two</span> _ _) <span class="fu">=</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb29-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb29-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">Sized</span> <span class="dt">IntList</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb29-8" data-line-number="8">  empty <span class="fu">=</span> <span class="dt">Nil</span></a>
-<a class="sourceLine" id="cb29-9" data-line-number="9">  size <span class="dt">Nil</span>               <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb29-10" data-line-number="10">  size (<span class="dt">ListNode</span> _ list) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> size list</a>
-<a class="sourceLine" id="cb29-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb29-12" data-line-number="12"><span class="kw">instance</span> <span class="dt">Sized</span> (<span class="dt">Tree</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb29-13" data-line-number="13">  empty <span class="fu">=</span> <span class="dt">Leaf</span></a>
-<a class="sourceLine" id="cb29-14" data-line-number="14">  size <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb29-15" data-line-number="15">  size (<span class="dt">Node</span> _ left right) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> size left <span class="fu">+</span> size right</a></code></pre></div>
+<div class="sourceCode" id="cb29"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb29-1" title="1"><span class="kw">instance</span> <span class="dt">Sized</span> <span class="dt">Numbers</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb29-2" title="2">  empty <span class="fu">=</span> <span class="dt">None</span></a>
+<a class="sourceLine" id="cb29-3" title="3">  size <span class="dt">None</span>      <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb29-4" title="4">  size (<span class="dt">One</span> _)   <span class="fu">=</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb29-5" title="5">  size (<span class="dt">Two</span> _ _) <span class="fu">=</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb29-6" title="6"></a>
+<a class="sourceLine" id="cb29-7" title="7"><span class="kw">instance</span> <span class="dt">Sized</span> <span class="dt">IntList</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb29-8" title="8">  empty <span class="fu">=</span> <span class="dt">Nil</span></a>
+<a class="sourceLine" id="cb29-9" title="9">  size <span class="dt">Nil</span>               <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb29-10" title="10">  size (<span class="dt">ListNode</span> _ list) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> size list</a>
+<a class="sourceLine" id="cb29-11" title="11"></a>
+<a class="sourceLine" id="cb29-12" title="12"><span class="kw">instance</span> <span class="dt">Sized</span> (<span class="dt">Tree</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb29-13" title="13">  empty <span class="fu">=</span> <span class="dt">Leaf</span></a>
+<a class="sourceLine" id="cb29-14" title="14">  size <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb29-15" title="15">  size (<span class="dt">Node</span> _ left right) <span class="fu">=</span> <span class="dv">1</span> <span class="fu">+</span> size left <span class="fu">+</span> size right</a></code></pre></div>
 <p>We can also easily declare <code>Eq</code> instances for <code>Numbers</code> and <code>IntList</code>:</p>
-<div class="sourceCode" id="cb30"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb30-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">Numbers</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb30-2" data-line-number="2">  <span class="dt">None</span>      <span class="fu">==</span> <span class="dt">None</span>       <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb30-3" data-line-number="3">  (<span class="dt">One</span> x)   <span class="fu">==</span> (<span class="dt">One</span> y)    <span class="fu">=</span> x<span class="fu">==</span>y</a>
-<a class="sourceLine" id="cb30-4" data-line-number="4">  (<span class="dt">Two</span> x y) <span class="fu">==</span> (<span class="dt">Two</span> z w)  <span class="fu">=</span> x<span class="fu">==</span>z <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>w</a>
-<a class="sourceLine" id="cb30-5" data-line-number="5">  _         <span class="fu">==</span> _          <span class="fu">=</span> <span class="dt">False</span>         <span class="co">-- to handle cases like None == One 1</span></a>
-<a class="sourceLine" id="cb30-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb30-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntList</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb30-8" data-line-number="8">  <span class="dt">Nil</span>             <span class="fu">==</span> <span class="dt">Nil</span>               <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb30-9" data-line-number="9">  (<span class="dt">ListNode</span> x xs) <span class="fu">==</span> (<span class="dt">ListNode</span> y ys)   <span class="fu">=</span> x <span class="fu">==</span> y <span class="fu">&amp;&amp;</span> xs <span class="fu">==</span> ys</a>
-<a class="sourceLine" id="cb30-10" data-line-number="10">  _               <span class="fu">==</span> _                 <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb30"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb30-1" title="1"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">Numbers</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb30-2" title="2">  <span class="dt">None</span>      <span class="fu">==</span> <span class="dt">None</span>       <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb30-3" title="3">  (<span class="dt">One</span> x)   <span class="fu">==</span> (<span class="dt">One</span> y)    <span class="fu">=</span> x<span class="fu">==</span>y</a>
+<a class="sourceLine" id="cb30-4" title="4">  (<span class="dt">Two</span> x y) <span class="fu">==</span> (<span class="dt">Two</span> z w)  <span class="fu">=</span> x<span class="fu">==</span>z <span class="fu">&amp;&amp;</span> y<span class="fu">==</span>w</a>
+<a class="sourceLine" id="cb30-5" title="5">  _         <span class="fu">==</span> _          <span class="fu">=</span> <span class="dt">False</span>         <span class="co">-- to handle cases like None == One 1</span></a>
+<a class="sourceLine" id="cb30-6" title="6"></a>
+<a class="sourceLine" id="cb30-7" title="7"><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntList</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb30-8" title="8">  <span class="dt">Nil</span>             <span class="fu">==</span> <span class="dt">Nil</span>               <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb30-9" title="9">  (<span class="dt">ListNode</span> x xs) <span class="fu">==</span> (<span class="dt">ListNode</span> y ys)   <span class="fu">=</span> x <span class="fu">==</span> y <span class="fu">&amp;&amp;</span> xs <span class="fu">==</span> ys</a>
+<a class="sourceLine" id="cb30-10" title="10">  _               <span class="fu">==</span> _                 <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <p>However, since the <code>Tree</code> datatype is parameterized over the element type <code>a</code>, we need an <code>Eq a</code> instance in order to have an <code>Eq (Tree a)</code> instance. This is achieved by adding a class constraint to the instance declaration. This is called an <em>instance hierarchy</em>.</p>
-<div class="sourceCode" id="cb31"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb31-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Tree</span> a) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb31-2" data-line-number="2">  <span class="dt">Leaf</span>         <span class="fu">==</span> <span class="dt">Leaf</span>              <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb31-3" data-line-number="3">  (<span class="dt">Node</span> x l r) <span class="fu">==</span> (<span class="dt">Node</span> x&#39; l&#39; r&#39;)   <span class="fu">=</span> x <span class="fu">==</span> x&#39; <span class="fu">&amp;&amp;</span> l <span class="fu">==</span> l&#39; <span class="fu">&amp;&amp;</span> r <span class="fu">==</span> r&#39;</a>
-<a class="sourceLine" id="cb31-4" data-line-number="4">  _            <span class="fu">==</span> _                 <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb31"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb31-1" title="1"><span class="kw">instance</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> <span class="dt">Eq</span> (<span class="dt">Tree</span> a) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb31-2" title="2">  <span class="dt">Leaf</span>         <span class="fu">==</span> <span class="dt">Leaf</span>              <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb31-3" title="3">  (<span class="dt">Node</span> x l r) <span class="fu">==</span> (<span class="dt">Node</span> x&#39; l&#39; r&#39;)   <span class="fu">=</span> x <span class="fu">==</span> x&#39; <span class="fu">&amp;&amp;</span> l <span class="fu">==</span> l&#39; <span class="fu">&amp;&amp;</span> r <span class="fu">==</span> r&#39;</a>
+<a class="sourceLine" id="cb31-4" title="4">  _            <span class="fu">==</span> _                 <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <h3 id="deriving"><span class="header-section-number">9.5.1</span> Deriving</h3>
 <p>Some standard type classes, most notably <code>Show</code>, <code>Read</code>, <code>Eq</code> and <code>Ord</code> can be <em>derived</em>, that is, you can ask the compiler to generate automatic instances for you. For example we could have derived all of these classes for our earlier <code>Numbers</code> example.</p>
-<div class="sourceCode" id="cb32"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb32-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Numbers</span> <span class="fu">=</span> <span class="dt">None</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Two</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb32-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Read</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb33"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb33-1" data-line-number="1"><span class="dt">None</span> <span class="fu">==</span> <span class="dt">One</span> <span class="dv">1</span>       <span class="fu">==&gt;</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb33-2" data-line-number="2"><span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span> <span class="fu">==</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb33-3" data-line-number="3"><span class="dt">None</span> <span class="fu">&lt;</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>      <span class="fu">==&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb33-4" data-line-number="4"><span class="dt">Two</span> <span class="dv">1</span> <span class="dv">3</span> <span class="fu">&lt;</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>   <span class="fu">==&gt;</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb33-5" data-line-number="5">show (<span class="dt">Two</span> <span class="dv">1</span> <span class="dv">3</span>)      <span class="fu">==&gt;</span> <span class="st">&quot;Two 1 3&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb32"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb32-1" title="1"><span class="kw">data</span> <span class="dt">Numbers</span> <span class="fu">=</span> <span class="dt">None</span> <span class="fu">|</span> <span class="dt">One</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Two</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb32-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Read</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb33"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb33-1" title="1"><span class="dt">None</span> <span class="fu">==</span> <span class="dt">One</span> <span class="dv">1</span>       <span class="fu">==&gt;</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb33-2" title="2"><span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span> <span class="fu">==</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb33-3" title="3"><span class="dt">None</span> <span class="fu">&lt;</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>      <span class="fu">==&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb33-4" title="4"><span class="dt">Two</span> <span class="dv">1</span> <span class="dv">3</span> <span class="fu">&lt;</span> <span class="dt">Two</span> <span class="dv">1</span> <span class="dv">2</span>   <span class="fu">==&gt;</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb33-5" title="5"><span class="fu">show</span> (<span class="dt">Two</span> <span class="dv">1</span> <span class="dv">3</span>)      <span class="fu">==&gt;</span> <span class="st">&quot;Two 1 3&quot;</span></a></code></pre></div>
 <h2 id="quiz"><span class="header-section-number">9.6</span> Quiz</h2>
 <p>What is the type of <code>('c',not)</code></p>
 <ol class="quiz">
@@ -732,7 +730,7 @@ It is a type error.
 </li>
 </ol>
 <p>Which of these is a value of the following type?</p>
-<div class="sourceCode" id="cb34"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb34-1" data-line-number="1"><span class="kw">data</span> <span class="dt">T</span> <span class="fu">=</span> <span class="dt">X</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Y</span> <span class="dt">String</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Z</span> <span class="dt">T</span></a></code></pre></div>
+<div class="sourceCode" id="cb34"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb34-1" title="1"><span class="kw">data</span> <span class="dt">T</span> <span class="fu">=</span> <span class="dt">X</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Y</span> <span class="dt">String</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Z</span> <span class="dt">T</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>X &quot;foo&quot;</code>
@@ -748,8 +746,8 @@ It is a type error.
 </li>
 </ol>
 <p>What is the type of this function?</p>
-<div class="sourceCode" id="cb35"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb35-1" data-line-number="1">f (_<span class="fu">:</span><span class="dt">Just</span> x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb35-2" data-line-number="2">f _            <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb35"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb35-1" title="1">f (_<span class="fu">:</span><span class="dt">Just</span> x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb35-2" title="2">f _            <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>Maybe a -&gt; a</code>
@@ -765,7 +763,7 @@ It is a type error.
 </li>
 </ol>
 <p>What is the type of this function?</p>
-<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb36-1" data-line-number="1">f x y <span class="fu">=</span> x<span class="fu">-</span>y <span class="fu">==</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb36-1" title="1">f x y <span class="fu">=</span> x<span class="fu">-</span>y <span class="fu">==</span> <span class="dv">0</span></a></code></pre></div>
 <ol class="quiz">
 <li class="correct">
 (Num a, Eq a) =&gt; a -&gt; a -&gt; Bool
@@ -821,10 +819,10 @@ It is a type error.
 <p>Haskell is a <em>pure</em> functional language. This means that the value <code>f x y</code> is always the same for given <code>x</code> and <code>y</code>. In other words, the values of <code>x</code> and <code>y</code> uniquely determine the value of <code>f x y</code>. This property is also called <em>referential transparency</em>.</p>
 <p>Purity also means that there are no side effects: you can’t have the evaluation of <code>f x y</code> read a line from the user - the line would be different on different invocations of <code>f</code> and would affect the return value, breaking referential transparency! Obviously you need side effects to actually get something done. We’ll get back to how Haskell handles side effects later.</p>
 <p>Haskell is a <em>lazy</em> language. This means that a value is not evaluated if it is not needed. An example illustrates this best. Consider these two functions:</p>
-<div class="sourceCode" id="cb37"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb37-1" data-line-number="1">f x <span class="fu">=</span> f x   <span class="co">-- infinite recursion</span></a>
-<a class="sourceLine" id="cb37-2" data-line-number="2">g x y <span class="fu">=</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb37"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb37-1" title="1">f x <span class="fu">=</span> f x   <span class="co">-- infinite recursion</span></a>
+<a class="sourceLine" id="cb37-2" title="2">g x y <span class="fu">=</span> x</a></code></pre></div>
 <p>Evaluating <code>f 1</code> does not halt due to the infinite recursion. However, this works:</p>
-<div class="sourceCode" id="cb38"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb38-1" data-line-number="1">g <span class="dv">2</span> (f <span class="dv">1</span>)  <span class="fu">==&gt;</span>  <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb38"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb38-1" title="1">g <span class="dv">2</span> (f <span class="dv">1</span>)  <span class="fu">==&gt;</span>  <span class="dv">2</span></a></code></pre></div>
 <p>Laziness is not a problem because Haskell is pure. Only the result of the function matters, not the side effects. So if the result of a function is not used, we can simply not evaluate it without changing the meaning (semantics) of a program. Well okay, sometimes we get a terminating program instead of one that goes on for ever, but adding laziness never makes a functioning Haskell program break.</p>
 <p>If you’re interested in the theory behind this, check out the <a href="https://en.wikipedia.org/wiki/Church%E2%80%93Rosser_theorem">Church-Rosser theorem</a> or the Haskell Wiki article <a href="https://wiki.haskell.org/Lazy_vs._non-strict">Lazy vs. non-strict</a>.</p>
 <h2 id="equational-reasoning"><span class="header-section-number">10.2</span> Equational Reasoning</h2>
@@ -837,7 +835,7 @@ int funny(int x) {
 <p>The expression <code>c++</code> increments the value of <code>c</code> and returns the old value of <code>c</code>. The next time it is evaluated, the value of <code>c</code> has increased by one. This means that depending on the current value of <code>c</code>, <code>funny(0)</code> might return <code>0</code>, <code>1</code>, <code>2</code>, or any other integer value. (It might even return negative values if <code>c</code> overflows!)</p>
 <p>In some situations this kind of behaviour with side-effects may be useful, but there are also times when it is more important to be able to reason about the code easily. The advantage of pure functions is that they can be analyzed using basic mathematical techniques. Sometimes applying math to our functions can even reveal simplifications or optimisations we otherwise wouldn’t have thought about.</p>
 <p>Consider the following expression:</p>
-<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb40-1" data-line-number="1">map (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> reverse <span class="fu">.</span> map (<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb40-1" title="1"><span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> <span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
 <p>This expression can be simplified to just <code>reverse</code>. We begin by establishing some helpful facts (or <em>lemmas</em>). First, suppose that we know</p>
 <ol type="1">
 <li><code>map id          === id</code></li>
@@ -849,46 +847,46 @@ int funny(int x) {
 <li><code>(+1) . (-1) === id</code></li>
 </ol>
 <p>We can prove fact 4 by reasoning about how <code>(+1) . (-1)</code> behaves for an arbitrary input <code>x</code>:</p>
-<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb41-1" data-line-number="1">((<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>)) x <span class="fu">===</span> ((<span class="fu">+</span><span class="dv">1</span>) ((<span class="fu">-</span><span class="dv">1</span>) x))</a>
-<a class="sourceLine" id="cb41-2" data-line-number="2">                <span class="fu">===</span> ((<span class="fu">+</span><span class="dv">1</span>) (x <span class="fu">-</span> <span class="dv">1</span>))</a>
-<a class="sourceLine" id="cb41-3" data-line-number="3">                <span class="fu">===</span> (x <span class="fu">-</span> <span class="dv">1</span>) <span class="fu">+</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb41-4" data-line-number="4">                <span class="fu">===</span> x</a>
-<a class="sourceLine" id="cb41-5" data-line-number="5">                <span class="fu">===</span> id x</a></code></pre></div>
+<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb41-1" title="1">((<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>)) x <span class="fu">===</span> ((<span class="fu">+</span><span class="dv">1</span>) ((<span class="fu">-</span><span class="dv">1</span>) x))</a>
+<a class="sourceLine" id="cb41-2" title="2">                <span class="fu">===</span> ((<span class="fu">+</span><span class="dv">1</span>) (x <span class="fu">-</span> <span class="dv">1</span>))</a>
+<a class="sourceLine" id="cb41-3" title="3">                <span class="fu">===</span> (x <span class="fu">-</span> <span class="dv">1</span>) <span class="fu">+</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb41-4" title="4">                <span class="fu">===</span> x</a>
+<a class="sourceLine" id="cb41-5" title="5">                <span class="fu">===</span> <span class="fu">id</span> x</a></code></pre></div>
 <p>Because we didn’t assume anything about <code>x</code>, we may conclude that the above chain of equations holds for <em>every</em> <code>x</code>. Thus,</p>
-<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb42-1" data-line-number="1">(<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>) <span class="fu">===</span> id</a></code></pre></div>
+<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb42-1" title="1">(<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>) <span class="fu">===</span> <span class="fu">id</span></a></code></pre></div>
 <p>For those who are familiar with the technique of <em>proof by induction</em>, it is a fun exercise to prove the first three facts also. This course doesn’t discuss induction proofs, though, so don’t sweat if you don’t know induction.</p>
 <p>Now, from facts 1-4 it follows that</p>
-<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb43-1" data-line-number="1">    map (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> reverse <span class="fu">.</span> map (<span class="fu">-</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb43-2" data-line-number="2"><span class="fu">===</span> map (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (reverse <span class="fu">.</span> map (<span class="fu">-</span><span class="dv">1</span>))    <span class="co">-- By associativity of (.)</span></a>
-<a class="sourceLine" id="cb43-3" data-line-number="3"><span class="fu">===</span> map (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (map (<span class="fu">-</span><span class="dv">1</span>) <span class="fu">.</span> reverse)    <span class="co">-- By fact 3</span></a>
-<a class="sourceLine" id="cb43-4" data-line-number="4"><span class="fu">===</span> (map (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> map (<span class="fu">-</span><span class="dv">1</span>)) <span class="fu">.</span> reverse    <span class="co">-- By associativity of (.)</span></a>
-<a class="sourceLine" id="cb43-5" data-line-number="5"><span class="fu">===</span> map ((<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>)) <span class="fu">.</span> reverse        <span class="co">-- By fact 2</span></a>
-<a class="sourceLine" id="cb43-6" data-line-number="6"><span class="fu">===</span> map id <span class="fu">.</span> reverse                   <span class="co">-- By fact 4</span></a>
-<a class="sourceLine" id="cb43-7" data-line-number="7"><span class="fu">===</span> id <span class="fu">.</span> reverse                       <span class="co">-- By fact 1</span></a>
-<a class="sourceLine" id="cb43-8" data-line-number="8"><span class="fu">===</span> reverse                            <span class="co">-- By the definition of id</span></a></code></pre></div>
+<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb43-1" title="1">    <span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> <span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">-</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb43-2" title="2"><span class="fu">===</span> <span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">-</span><span class="dv">1</span>))    <span class="co">-- By associativity of (.)</span></a>
+<a class="sourceLine" id="cb43-3" title="3"><span class="fu">===</span> <span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">map</span> (<span class="fu">-</span><span class="dv">1</span>) <span class="fu">.</span> <span class="fu">reverse</span>)    <span class="co">-- By fact 3</span></a>
+<a class="sourceLine" id="cb43-4" title="4"><span class="fu">===</span> (<span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">-</span><span class="dv">1</span>)) <span class="fu">.</span> <span class="fu">reverse</span>    <span class="co">-- By associativity of (.)</span></a>
+<a class="sourceLine" id="cb43-5" title="5"><span class="fu">===</span> <span class="fu">map</span> ((<span class="fu">+</span><span class="dv">1</span>) <span class="fu">.</span> (<span class="fu">-</span><span class="dv">1</span>)) <span class="fu">.</span> <span class="fu">reverse</span>        <span class="co">-- By fact 2</span></a>
+<a class="sourceLine" id="cb43-6" title="6"><span class="fu">===</span> <span class="fu">map</span> <span class="fu">id</span> <span class="fu">.</span> <span class="fu">reverse</span>                   <span class="co">-- By fact 4</span></a>
+<a class="sourceLine" id="cb43-7" title="7"><span class="fu">===</span> <span class="fu">id</span> <span class="fu">.</span> <span class="fu">reverse</span>                       <span class="co">-- By fact 1</span></a>
+<a class="sourceLine" id="cb43-8" title="8"><span class="fu">===</span> <span class="fu">reverse</span>                            <span class="co">-- By the definition of id</span></a></code></pre></div>
 <p>This course won’t go into details about proving things about programs, but it’s good to know that pure functional programming is very compatible with analysis like this.</p>
 <h2 id="infinite-lists"><span class="header-section-number">10.3</span> Infinite Lists</h2>
 <p>The benefits of laziness are best demonstrated with some examples involving <em>infinite lists</em>. Let’s start with <code>repeat 1</code>, which generates an infinite list of <code>1</code>s. If we try to tell GHCi to print the value <code>repeat 1</code>, it will just keep printing <code>1</code>s for ever until we interrupt it using Control-C:</p>
-<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb44-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> repeat <span class="dv">1</span></a>
-<a class="sourceLine" id="cb44-2" data-line-number="2">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span></a>
-<a class="sourceLine" id="cb44-3" data-line-number="3"><span class="fu">^</span><span class="dt">C</span></a></code></pre></div>
+<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb44-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">repeat</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb44-2" title="2">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span></a>
+<a class="sourceLine" id="cb44-3" title="3"><span class="fu">^</span><span class="dt">C</span></a></code></pre></div>
 <p>However, due to laziness, we can work with infinite lists and write computations that end. We just need to use a finite number of elements from the infinite list. Here are some examples:</p>
-<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb45-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">10</span> <span class="fu">$</span> repeat <span class="dv">1</span></a>
-<a class="sourceLine" id="cb45-2" data-line-number="2">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb45-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">20</span> <span class="fu">$</span> repeat <span class="dv">1</span></a>
-<a class="sourceLine" id="cb45-4" data-line-number="4">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb45-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> repeat <span class="dv">1</span> <span class="fu">!!</span> <span class="dv">13337</span></a>
-<a class="sourceLine" id="cb45-6" data-line-number="6"><span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb45-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">10</span> <span class="fu">$</span> <span class="fu">repeat</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb45-2" title="2">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb45-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">20</span> <span class="fu">$</span> <span class="fu">repeat</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb45-4" title="4">[<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb45-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">repeat</span> <span class="dv">1</span> <span class="fu">!!</span> <span class="dv">13337</span></a>
+<a class="sourceLine" id="cb45-6" title="6"><span class="dv">1</span></a></code></pre></div>
 <p>An infinite list that just repeats one element can sometimes be necessary, but it’s kind of pointless. Let’s look at some more useful infinite lists next. You can use the <code>[n..]</code> syntax to generate an infinite list of numbers, starting from <code>n</code>:</p>
-<div class="sourceCode" id="cb46"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb46-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">20</span> [<span class="dv">0</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb46-2" data-line-number="2">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>,<span class="dv">10</span>,<span class="dv">11</span>,<span class="dv">12</span>,<span class="dv">13</span>,<span class="dv">14</span>,<span class="dv">15</span>,<span class="dv">16</span>,<span class="dv">17</span>,<span class="dv">18</span>,<span class="dv">19</span>]</a>
-<a class="sourceLine" id="cb46-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">10</span> <span class="fu">.</span> map (<span class="dv">2</span><span class="fu">^</span>) <span class="fu">$</span> [<span class="dv">0</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb46-4" data-line-number="4">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">8</span>,<span class="dv">16</span>,<span class="dv">32</span>,<span class="dv">64</span>,<span class="dv">128</span>,<span class="dv">256</span>,<span class="dv">512</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb46"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb46-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">20</span> [<span class="dv">0</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb46-2" title="2">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>,<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>,<span class="dv">10</span>,<span class="dv">11</span>,<span class="dv">12</span>,<span class="dv">13</span>,<span class="dv">14</span>,<span class="dv">15</span>,<span class="dv">16</span>,<span class="dv">17</span>,<span class="dv">18</span>,<span class="dv">19</span>]</a>
+<a class="sourceLine" id="cb46-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">10</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="dv">2</span><span class="fu">^</span>) <span class="fu">$</span> [<span class="dv">0</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb46-4" title="4">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">8</span>,<span class="dv">16</span>,<span class="dv">32</span>,<span class="dv">64</span>,<span class="dv">128</span>,<span class="dv">256</span>,<span class="dv">512</span>]</a></code></pre></div>
 <p>The function <code>cycle</code> repeats elements from the given list over and over again. It can be useful when dealing with rotations or cycles.</p>
-<div class="sourceCode" id="cb47"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb47-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">21</span> <span class="fu">$</span> cycle <span class="st">&quot;asdf&quot;</span></a>
-<a class="sourceLine" id="cb47-2" data-line-number="2"><span class="st">&quot;asdfasdfasdfasdfasdfa&quot;</span></a>
-<a class="sourceLine" id="cb47-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">4</span> <span class="fu">.</span> map (take <span class="dv">4</span>) <span class="fu">.</span> tails <span class="fu">$</span> cycle <span class="st">&quot;asdf&quot;</span></a>
-<a class="sourceLine" id="cb47-4" data-line-number="4">[<span class="st">&quot;asdf&quot;</span>,<span class="st">&quot;sdfa&quot;</span>,<span class="st">&quot;dfas&quot;</span>,<span class="st">&quot;fasd&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb47"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb47-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">21</span> <span class="fu">$</span> <span class="fu">cycle</span> <span class="st">&quot;asdf&quot;</span></a>
+<a class="sourceLine" id="cb47-2" title="2"><span class="st">&quot;asdfasdfasdfasdfasdfa&quot;</span></a>
+<a class="sourceLine" id="cb47-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">4</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">take</span> <span class="dv">4</span>) <span class="fu">.</span> tails <span class="fu">$</span> <span class="fu">cycle</span> <span class="st">&quot;asdf&quot;</span></a>
+<a class="sourceLine" id="cb47-4" title="4">[<span class="st">&quot;asdf&quot;</span>,<span class="st">&quot;sdfa&quot;</span>,<span class="st">&quot;dfas&quot;</span>,<span class="st">&quot;fasd&quot;</span>]</a></code></pre></div>
 <h3 id="example-transaction-numbers"><span class="header-section-number">10.3.1</span> Example: Transaction Numbers</h3>
 <p>As a more concrete example of how <code>cycle</code> is useful, let’s look at computing the check digit of Finnish bank transfer transaction numbers (<a href="https://fi.wikipedia.org/wiki/Tilisiirto#Viitenumero">viitenumero</a>). A transaction number consists of any number of digits, followed by a single check digit. The check digit is checked by multiplying the digits (from right to left) with the numbers 7, 3, 1, 7, 3, 1 and so on, and summing the results. If the result of the sum <em>plus the check digit</em> is divisible by 10, the number is valid.</p>
 <p>Here’s a concrete example. <code>116127</code> is a valid transaction number. The computation goes like this:</p>
@@ -898,97 +896,97 @@ multipliers:  3  7  1  3  7
               3+ 7+ 6+ 3+14 = 33
 check digit is 7, 33+7=40 is divisible by 10, valid</code></pre>
 <p>Here’s the Haskell code for a transaction number checker. Note how we use use the infinite list <code>cycle [7,3,1]</code> for the multipliers.</p>
-<div class="sourceCode" id="cb49"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb49-1" data-line-number="1"><span class="ot">viitenumeroCheck ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb49-2" data-line-number="2">viitenumeroCheck allDigits <span class="fu">=</span> mod (checksum<span class="fu">+</span>checkDigit) <span class="dv">10</span> <span class="fu">==</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb49-3" data-line-number="3">  <span class="kw">where</span> (checkDigit<span class="fu">:</span>digits) <span class="fu">=</span> reverse allDigits</a>
-<a class="sourceLine" id="cb49-4" data-line-number="4">        multipliers <span class="fu">=</span> cycle [<span class="dv">7</span>,<span class="dv">3</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb49-5" data-line-number="5">        checksum <span class="fu">=</span> sum <span class="fu">$</span> zipWith (<span class="fu">*</span>) multipliers digits</a></code></pre></div>
-<div class="sourceCode" id="cb50"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb50-1" data-line-number="1">viitenumeroCheck [<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>]  <span class="fu">==&gt;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb50-2" data-line-number="2">viitenumeroCheck [<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">8</span>]  <span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb49"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb49-1" title="1"><span class="ot">viitenumeroCheck ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb49-2" title="2">viitenumeroCheck allDigits <span class="fu">=</span> <span class="fu">mod</span> (checksum<span class="fu">+</span>checkDigit) <span class="dv">10</span> <span class="fu">==</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb49-3" title="3">  <span class="kw">where</span> (checkDigit<span class="fu">:</span>digits) <span class="fu">=</span> <span class="fu">reverse</span> allDigits</a>
+<a class="sourceLine" id="cb49-4" title="4">        multipliers <span class="fu">=</span> <span class="fu">cycle</span> [<span class="dv">7</span>,<span class="dv">3</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb49-5" title="5">        checksum <span class="fu">=</span> <span class="fu">sum</span> <span class="fu">$</span> <span class="fu">zipWith</span> (<span class="fu">*</span>) multipliers digits</a></code></pre></div>
+<div class="sourceCode" id="cb50"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb50-1" title="1">viitenumeroCheck [<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>]  <span class="fu">==&gt;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb50-2" title="2">viitenumeroCheck [<span class="dv">1</span>,<span class="dv">1</span>,<span class="dv">6</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">8</span>]  <span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
 <h3 id="example-finding-a-power"><span class="header-section-number">10.3.2</span> Example: Finding a Power</h3>
 <p>Finally, here’s how you would find the first power of 3 that’s larger than 100.</p>
-<div class="sourceCode" id="cb51"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb51-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> head <span class="fu">.</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) <span class="fu">$</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb51-2" data-line-number="2"><span class="dv">243</span></a></code></pre></div>
+<div class="sourceCode" id="cb51"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb51-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> <span class="fu">.</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) <span class="fu">$</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb51-2" title="2"><span class="dv">243</span></a></code></pre></div>
 <p>Let’s go through how this works step by step. Note how map and filter are processing the list lazily, one element at a time, as needed. This is similar to how <em>generators</em> or <em>iterators</em> work in languages like Python or Java.</p>
-<div class="sourceCode" id="cb52"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb52-1" data-line-number="1">    head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb52-2" data-line-number="2"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">0</span><span class="fu">:</span>[<span class="dv">1</span><span class="fu">..</span>])))   <span class="co">-- evaluate first element of the lazy list</span></a>
-<a class="sourceLine" id="cb52-3" data-line-number="3"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">1</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))   <span class="co">-- map processes the element</span></a>
-<a class="sourceLine" id="cb52-4" data-line-number="4"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))       <span class="co">-- filter drops the element</span></a>
-<a class="sourceLine" id="cb52-5" data-line-number="5"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span><span class="fu">..</span>])))   <span class="co">-- evaluate second element of the lazy list</span></a>
-<a class="sourceLine" id="cb52-6" data-line-number="6"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">3</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))   <span class="co">-- map processes the element</span></a>
-<a class="sourceLine" id="cb52-7" data-line-number="7"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))       <span class="co">-- filter drops the element</span></a>
-<a class="sourceLine" id="cb52-8" data-line-number="8"><span class="co">-- let&#39;s take bigger steps now</span></a>
-<a class="sourceLine" id="cb52-9" data-line-number="9"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">9</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">3</span><span class="fu">..</span>]))   <span class="co">-- map processes, filter will drop</span></a>
-<a class="sourceLine" id="cb52-10" data-line-number="10"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">27</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">4</span><span class="fu">..</span>]))  <span class="co">-- map processes, filter will drop</span></a>
-<a class="sourceLine" id="cb52-11" data-line-number="11"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">81</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">5</span><span class="fu">..</span>]))  <span class="co">-- map processes, filter will drop</span></a>
-<a class="sourceLine" id="cb52-12" data-line-number="12"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">243</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>])) <span class="co">-- map processes</span></a>
-<a class="sourceLine" id="cb52-13" data-line-number="13"><span class="fu">==&gt;</span> head (<span class="dv">243</span> <span class="fu">:</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>])) <span class="co">-- filter lets the value through</span></a>
-<a class="sourceLine" id="cb52-14" data-line-number="14"><span class="fu">==&gt;</span> <span class="dv">243</span>                                         <span class="co">-- head returns the result</span></a></code></pre></div>
+<div class="sourceCode" id="cb52"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb52-1" title="1">    <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb52-2" title="2"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">0</span><span class="fu">:</span>[<span class="dv">1</span><span class="fu">..</span>])))   <span class="co">-- evaluate first element of the lazy list</span></a>
+<a class="sourceLine" id="cb52-3" title="3"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">1</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))   <span class="co">-- map processes the element</span></a>
+<a class="sourceLine" id="cb52-4" title="4"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))       <span class="co">-- filter drops the element</span></a>
+<a class="sourceLine" id="cb52-5" title="5"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span><span class="fu">..</span>])))   <span class="co">-- evaluate second element of the lazy list</span></a>
+<a class="sourceLine" id="cb52-6" title="6"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">3</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))   <span class="co">-- map processes the element</span></a>
+<a class="sourceLine" id="cb52-7" title="7"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))       <span class="co">-- filter drops the element</span></a>
+<a class="sourceLine" id="cb52-8" title="8"><span class="co">-- let&#39;s take bigger steps now</span></a>
+<a class="sourceLine" id="cb52-9" title="9"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">9</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">3</span><span class="fu">..</span>]))   <span class="co">-- map processes, filter will drop</span></a>
+<a class="sourceLine" id="cb52-10" title="10"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">27</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">4</span><span class="fu">..</span>]))  <span class="co">-- map processes, filter will drop</span></a>
+<a class="sourceLine" id="cb52-11" title="11"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">81</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">5</span><span class="fu">..</span>]))  <span class="co">-- map processes, filter will drop</span></a>
+<a class="sourceLine" id="cb52-12" title="12"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">243</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>])) <span class="co">-- map processes</span></a>
+<a class="sourceLine" id="cb52-13" title="13"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="dv">243</span> <span class="fu">:</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>])) <span class="co">-- filter lets the value through</span></a>
+<a class="sourceLine" id="cb52-14" title="14"><span class="fu">==&gt;</span> <span class="dv">243</span>                                         <span class="co">-- head returns the result</span></a></code></pre></div>
 <h2 id="how-does-haskell-work"><span class="header-section-number">10.4</span> How does Haskell Work?</h2>
 <p>Laziness will probably feel a bit magical to you right now. You might wonder how it can be implemented. Haskell evaluation is remarkably simple, it’s just different than what you might be used to. Let’s dig in.</p>
 <p>In most other programming languages (like Java, C or Python), evaluation proceeds inside-out. Arguments to functions are evaluated before the function.</p>
 <p>Haskell evaluation proceeds outside-in instead of inside-out. The definition of the outermost function in an expression is applied without evaluating any arguments. Here’s a concrete example with toy functions <code>f</code> and <code>g</code>:</p>
-<div class="sourceCode" id="cb53"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb53-1" data-line-number="1"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-2" data-line-number="2">g x y <span class="fu">=</span> y<span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb53-3" data-line-number="3"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb53-4" data-line-number="4">f a b c <span class="fu">=</span> g (a<span class="fu">*</span><span class="dv">1000</span>) c</a></code></pre></div>
+<div class="sourceCode" id="cb53"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb53-1" title="1"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-2" title="2">g x y <span class="fu">=</span> y<span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb53-3" title="3"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb53-4" title="4">f a b c <span class="fu">=</span> g (a<span class="fu">*</span><span class="dv">1000</span>) c</a></code></pre></div>
 <p>Inside-out (normal) evaluation:</p>
-<div class="sourceCode" id="cb54"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb54-1" data-line-number="1">f <span class="dv">1</span> (<span class="dv">1234</span><span class="fu">*</span><span class="dv">1234</span>) <span class="dv">2</span></a>
-<a class="sourceLine" id="cb54-2" data-line-number="2">  <span class="co">-- evaluate arguments to f</span></a>
-<a class="sourceLine" id="cb54-3" data-line-number="3">  <span class="fu">==&gt;</span> f <span class="dv">1</span> <span class="dv">1522756</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb54-4" data-line-number="4">  <span class="co">-- evaluate f</span></a>
-<a class="sourceLine" id="cb54-5" data-line-number="5">  <span class="fu">==&gt;</span> g (<span class="dv">1</span><span class="fu">*</span><span class="dv">1000</span>) <span class="dv">2</span></a>
-<a class="sourceLine" id="cb54-6" data-line-number="6">  <span class="co">-- evaluate arguments to g</span></a>
-<a class="sourceLine" id="cb54-7" data-line-number="7">  <span class="fu">==&gt;</span> g <span class="dv">1000</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb54-8" data-line-number="8">  <span class="co">-- evaluate g</span></a>
-<a class="sourceLine" id="cb54-9" data-line-number="9">  <span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb54-10" data-line-number="10">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb54"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb54-1" title="1">f <span class="dv">1</span> (<span class="dv">1234</span><span class="fu">*</span><span class="dv">1234</span>) <span class="dv">2</span></a>
+<a class="sourceLine" id="cb54-2" title="2">  <span class="co">-- evaluate arguments to f</span></a>
+<a class="sourceLine" id="cb54-3" title="3">  <span class="fu">==&gt;</span> f <span class="dv">1</span> <span class="dv">1522756</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb54-4" title="4">  <span class="co">-- evaluate f</span></a>
+<a class="sourceLine" id="cb54-5" title="5">  <span class="fu">==&gt;</span> g (<span class="dv">1</span><span class="fu">*</span><span class="dv">1000</span>) <span class="dv">2</span></a>
+<a class="sourceLine" id="cb54-6" title="6">  <span class="co">-- evaluate arguments to g</span></a>
+<a class="sourceLine" id="cb54-7" title="7">  <span class="fu">==&gt;</span> g <span class="dv">1000</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb54-8" title="8">  <span class="co">-- evaluate g</span></a>
+<a class="sourceLine" id="cb54-9" title="9">  <span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb54-10" title="10">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>Haskell outside-in evaluation:</p>
-<div class="sourceCode" id="cb55"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb55-1" data-line-number="1">f <span class="dv">1</span> (<span class="dv">1234</span><span class="fu">*</span><span class="dv">1234</span>) <span class="dv">2</span></a>
-<a class="sourceLine" id="cb55-2" data-line-number="2">  <span class="co">-- evaluate f without evaluating arguments</span></a>
-<a class="sourceLine" id="cb55-3" data-line-number="3">  <span class="fu">==&gt;</span> g (<span class="dv">1</span><span class="fu">*</span><span class="dv">1000</span>) <span class="dv">2</span></a>
-<a class="sourceLine" id="cb55-4" data-line-number="4">  <span class="co">-- evaluate g without evaluating arguments</span></a>
-<a class="sourceLine" id="cb55-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">+</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb55-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb55"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb55-1" title="1">f <span class="dv">1</span> (<span class="dv">1234</span><span class="fu">*</span><span class="dv">1234</span>) <span class="dv">2</span></a>
+<a class="sourceLine" id="cb55-2" title="2">  <span class="co">-- evaluate f without evaluating arguments</span></a>
+<a class="sourceLine" id="cb55-3" title="3">  <span class="fu">==&gt;</span> g (<span class="dv">1</span><span class="fu">*</span><span class="dv">1000</span>) <span class="dv">2</span></a>
+<a class="sourceLine" id="cb55-4" title="4">  <span class="co">-- evaluate g without evaluating arguments</span></a>
+<a class="sourceLine" id="cb55-5" title="5">  <span class="fu">==&gt;</span> <span class="dv">2</span><span class="fu">+</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb55-6" title="6">  <span class="fu">==&gt;</span> <span class="dv">3</span></a></code></pre></div>
 <p>Note how the unused calculations <code>1234*1234</code> and <code>1*1000</code> didn’t get evaluated. This is why laziness is often helpful.</p>
 <h3 id="pattern-matching-drives-evaluation"><span class="header-section-number">10.4.1</span> Pattern Matching Drives Evaluation</h3>
 <p>Let’s look at a more involved example, with pattern matching and more complex data (lists). Pattern matching drives Haskell evaluation in a very concrete way, as we’ll see. Here are some functions that we’ll use. They’re familiar from the Prelude, but I’ll give them simple definitions.</p>
-<div class="sourceCode" id="cb56"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb56-1" data-line-number="1">not <span class="dt">True</span> <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb56-2" data-line-number="2">not <span class="dt">False</span> <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb56-3" data-line-number="3">map f [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb56-4" data-line-number="4">map f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> map f xs</a>
-<a class="sourceLine" id="cb56-5" data-line-number="5">length [] <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb56-6" data-line-number="6">length (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">1</span><span class="fu">+</span>length xs</a></code></pre></div>
+<div class="sourceCode" id="cb56"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb56-1" title="1"><span class="fu">not</span> <span class="dt">True</span> <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb56-2" title="2"><span class="fu">not</span> <span class="dt">False</span> <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb56-3" title="3"><span class="fu">map</span> f [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb56-4" title="4"><span class="fu">map</span> f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> <span class="fu">map</span> f xs</a>
+<a class="sourceLine" id="cb56-5" title="5"><span class="fu">length</span> [] <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb56-6" title="6"><span class="fu">length</span> (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dv">1</span><span class="fu">+length</span> xs</a></code></pre></div>
 <p>Here’s the inside-out evaluation of an expression:</p>
-<div class="sourceCode" id="cb57"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb57-1" data-line-number="1">length (map not (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb57-2" data-line-number="2">  <span class="fu">==&gt;</span> length (not <span class="dt">True</span> <span class="fu">:</span> not <span class="dt">False</span> <span class="fu">:</span> [])  <span class="co">-- evaluate call to map</span></a>
-<a class="sourceLine" id="cb57-3" data-line-number="3">  <span class="fu">==&gt;</span> length (<span class="dt">False</span><span class="fu">:</span><span class="dt">True</span><span class="fu">:</span>[])              <span class="co">-- evaluate calls to not</span></a>
-<a class="sourceLine" id="cb57-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb57"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb57-1" title="1"><span class="fu">length</span> (<span class="fu">map</span> <span class="fu">not</span> (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb57-2" title="2">  <span class="fu">==&gt;</span> <span class="fu">length</span> (<span class="fu">not</span> <span class="dt">True</span> <span class="fu">:</span> <span class="fu">not</span> <span class="dt">False</span> <span class="fu">:</span> [])  <span class="co">-- evaluate call to map</span></a>
+<a class="sourceLine" id="cb57-3" title="3">  <span class="fu">==&gt;</span> <span class="fu">length</span> (<span class="dt">False</span><span class="fu">:</span><span class="dt">True</span><span class="fu">:</span>[])              <span class="co">-- evaluate calls to not</span></a>
+<a class="sourceLine" id="cb57-4" title="4">  <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
 <p>Here’s how the evaluation proceeds in Haskell. Note how it’s not strictly outside-in, since we sometimes need to evaluate inside arguments to be able to know which pattern is matched.</p>
-<div class="sourceCode" id="cb58"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb58-1" data-line-number="1">length (map not (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb58-2" data-line-number="2">  <span class="co">-- We can&#39;t evaluate length since we don&#39;t know which equation of length applies,</span></a>
-<a class="sourceLine" id="cb58-3" data-line-number="3">  <span class="co">-- so we look at length&#39;s argument. We can apply the second equation of map, so we do.</span></a>
-<a class="sourceLine" id="cb58-4" data-line-number="4">  <span class="fu">==&gt;</span> length (not <span class="dt">True</span> <span class="fu">:</span> map not (<span class="dt">False</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb58-5" data-line-number="5">  <span class="co">-- Now the argument of length has a (:) we can pattern match on, so we apply the</span></a>
-<a class="sourceLine" id="cb58-6" data-line-number="6">  <span class="co">-- second equation of length</span></a>
-<a class="sourceLine" id="cb58-7" data-line-number="7">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> length (map not (<span class="dt">False</span><span class="fu">:</span>[]))</a>
-<a class="sourceLine" id="cb58-8" data-line-number="8">  <span class="co">-- The outermost function is now +, but it can&#39;t do anything unless both arguments</span></a>
-<a class="sourceLine" id="cb58-9" data-line-number="9">  <span class="co">-- are numbers. So we need to evaluate length. In order to pick an equation, we need</span></a>
-<a class="sourceLine" id="cb58-10" data-line-number="10">  <span class="co">-- to evaluate the argument of length again. We apply the second equation of map</span></a>
-<a class="sourceLine" id="cb58-11" data-line-number="11">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> length (not <span class="dt">False</span> <span class="fu">:</span> map not ([]))</a>
-<a class="sourceLine" id="cb58-12" data-line-number="12">  <span class="co">-- Now we can apply the second equation of length again.</span></a>
-<a class="sourceLine" id="cb58-13" data-line-number="13">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> length (map not []))</a>
-<a class="sourceLine" id="cb58-14" data-line-number="14">  <span class="co">-- The outermost + needs a number to be evaluated. The second + also needs a number.</span></a>
-<a class="sourceLine" id="cb58-15" data-line-number="15">  <span class="co">-- We need to evaluate length again, which means we need to pick an equation for length,</span></a>
-<a class="sourceLine" id="cb58-16" data-line-number="16">  <span class="co">-- which means we need to evaluate its argument. This time it is the first equation for</span></a>
-<a class="sourceLine" id="cb58-17" data-line-number="17">  <span class="co">-- map that applies.</span></a>
-<a class="sourceLine" id="cb58-18" data-line-number="18">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> length [])</a>
-<a class="sourceLine" id="cb58-19" data-line-number="19">  <span class="co">-- Now we can apply the first equation for length</span></a>
-<a class="sourceLine" id="cb58-20" data-line-number="20">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> <span class="dv">0</span>)</a>
-<a class="sourceLine" id="cb58-21" data-line-number="21">  <span class="co">-- The outermost + still can&#39;t be evaluated, but the inner one can</span></a>
-<a class="sourceLine" id="cb58-22" data-line-number="22">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb58-23" data-line-number="23">  <span class="co">-- Finally we evaluate the outer +</span></a>
-<a class="sourceLine" id="cb58-24" data-line-number="24">  <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb58"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb58-1" title="1"><span class="fu">length</span> (<span class="fu">map</span> <span class="fu">not</span> (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb58-2" title="2">  <span class="co">-- We can&#39;t evaluate length since we don&#39;t know which equation of length applies,</span></a>
+<a class="sourceLine" id="cb58-3" title="3">  <span class="co">-- so we look at length&#39;s argument. We can apply the second equation of map, so we do.</span></a>
+<a class="sourceLine" id="cb58-4" title="4">  <span class="fu">==&gt;</span> <span class="fu">length</span> (<span class="fu">not</span> <span class="dt">True</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">not</span> (<span class="dt">False</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb58-5" title="5">  <span class="co">-- Now the argument of length has a (:) we can pattern match on, so we apply the</span></a>
+<a class="sourceLine" id="cb58-6" title="6">  <span class="co">-- second equation of length</span></a>
+<a class="sourceLine" id="cb58-7" title="7">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">length</span> (<span class="fu">map</span> <span class="fu">not</span> (<span class="dt">False</span><span class="fu">:</span>[]))</a>
+<a class="sourceLine" id="cb58-8" title="8">  <span class="co">-- The outermost function is now +, but it can&#39;t do anything unless both arguments</span></a>
+<a class="sourceLine" id="cb58-9" title="9">  <span class="co">-- are numbers. So we need to evaluate length. In order to pick an equation, we need</span></a>
+<a class="sourceLine" id="cb58-10" title="10">  <span class="co">-- to evaluate the argument of length again. We apply the second equation of map</span></a>
+<a class="sourceLine" id="cb58-11" title="11">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">length</span> (<span class="fu">not</span> <span class="dt">False</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">not</span> ([]))</a>
+<a class="sourceLine" id="cb58-12" title="12">  <span class="co">-- Now we can apply the second equation of length again.</span></a>
+<a class="sourceLine" id="cb58-13" title="13">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> <span class="fu">length</span> (<span class="fu">map</span> <span class="fu">not</span> []))</a>
+<a class="sourceLine" id="cb58-14" title="14">  <span class="co">-- The outermost + needs a number to be evaluated. The second + also needs a number.</span></a>
+<a class="sourceLine" id="cb58-15" title="15">  <span class="co">-- We need to evaluate length again, which means we need to pick an equation for length,</span></a>
+<a class="sourceLine" id="cb58-16" title="16">  <span class="co">-- which means we need to evaluate its argument. This time it is the first equation for</span></a>
+<a class="sourceLine" id="cb58-17" title="17">  <span class="co">-- map that applies.</span></a>
+<a class="sourceLine" id="cb58-18" title="18">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> <span class="fu">length</span> [])</a>
+<a class="sourceLine" id="cb58-19" title="19">  <span class="co">-- Now we can apply the first equation for length</span></a>
+<a class="sourceLine" id="cb58-20" title="20">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">1</span> <span class="fu">+</span> <span class="dv">0</span>)</a>
+<a class="sourceLine" id="cb58-21" title="21">  <span class="co">-- The outermost + still can&#39;t be evaluated, but the inner one can</span></a>
+<a class="sourceLine" id="cb58-22" title="22">  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb58-23" title="23">  <span class="co">-- Finally we evaluate the outer +</span></a>
+<a class="sourceLine" id="cb58-24" title="24">  <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
 <p>Note that we didn’t need to evaluate any of the <code>not</code> applications.</p>
 <p>Let’s introduce some terminology. We say that pattern matching <em>forces</em> evaluation. When Haskell evaluates something, it evaluates it to something called <em>weak head normal form (WHNF)</em>. WHNF basically means <em>a value that can be pattern matched on</em>. An expression is in WHNF if it can’t be evaluated on <em>its top level</em>. This means it either:</p>
 <ul>
@@ -1003,13 +1001,13 @@ check digit is 7, 33+7=40 is divisible by 10, valid</code></pre>
 <h3 id="a-word-about-sharing"><span class="header-section-number">10.4.2</span> A Word About Sharing</h3>
 <p>There’s one more thing about Haskell evaluation. Any time you give a value a <em>name</em>, it gets <em>shared</em>. This means that every occurrence of the name points at the same (potentially unevaluated) expression. When the expression gets evaluated, all occurrences of the name see the result.</p>
 <p>Let’s look at a very simple example.</p>
-<div class="sourceCode" id="cb59"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb59-1" data-line-number="1">square x <span class="fu">=</span> x<span class="fu">*</span>x</a></code></pre></div>
+<div class="sourceCode" id="cb59"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb59-1" title="1">square x <span class="fu">=</span> x<span class="fu">*</span>x</a></code></pre></div>
 <p>Based on the previous sections, you might imagine evaluation works like the following. The evaluation is first represented textually, and then visually, as an expression tree.</p>
-<div class="sourceCode" id="cb60"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb60-1" data-line-number="1">square (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb60-2" data-line-number="2">  <span class="fu">==&gt;</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>) <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)   <span class="co">-- definition of square</span></a>
-<a class="sourceLine" id="cb60-3" data-line-number="3">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)   <span class="co">-- (*) forces left argument</span></a>
-<a class="sourceLine" id="cb60-4" data-line-number="4">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span>   <span class="dv">4</span>     <span class="co">-- (*) forces right argument</span></a>
-<a class="sourceLine" id="cb60-5" data-line-number="5">  <span class="fu">==&gt;</span>      <span class="dv">16</span>         <span class="co">-- definition of (*)</span></a></code></pre></div>
+<div class="sourceCode" id="cb60"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb60-1" title="1">square (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb60-2" title="2">  <span class="fu">==&gt;</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>) <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)   <span class="co">-- definition of square</span></a>
+<a class="sourceLine" id="cb60-3" title="3">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)   <span class="co">-- (*) forces left argument</span></a>
+<a class="sourceLine" id="cb60-4" title="4">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span>   <span class="dv">4</span>     <span class="co">-- (*) forces right argument</span></a>
+<a class="sourceLine" id="cb60-5" title="5">  <span class="fu">==&gt;</span>      <span class="dv">16</span>         <span class="co">-- definition of (*)</span></a></code></pre></div>
 <!--
 ```haskell
 square   ==>   *     ==>     *    ==>    *    ==>   16
@@ -1021,10 +1019,10 @@ square   ==>   *     ==>     *    ==>    *    ==>   16
 -->
 <p><img src="img/square1.svg" /></p>
 <p>However, what really happens is that the expression <code>2+2</code> named by the variable <code>x</code> is only computed once. The result of the evaluation is then shared between the two occurrences of <code>x</code> inside <code>square</code>. So here’s the correct evaluation, first textually, and then visually. Note how now instead of an expression tree, we have an <em>expression graph</em>. This is why Haskell evaluation is sometimes called <a href="https://en.wikipedia.org/wiki/Graph_reduction"><em>graph reduction</em></a>.</p>
-<div class="sourceCode" id="cb61"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb61-1" data-line-number="1">square (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb61-2" data-line-number="2">  <span class="fu">==&gt;</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>) <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb61-3" data-line-number="3">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span>   <span class="dv">4</span></a>
-<a class="sourceLine" id="cb61-4" data-line-number="4">  <span class="fu">==&gt;</span>      <span class="dv">16</span></a></code></pre></div>
+<div class="sourceCode" id="cb61"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb61-1" title="1">square (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb61-2" title="2">  <span class="fu">==&gt;</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>) <span class="fu">*</span> (<span class="dv">2</span><span class="fu">+</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb61-3" title="3">  <span class="fu">==&gt;</span>   <span class="dv">4</span>   <span class="fu">*</span>   <span class="dv">4</span></a>
+<a class="sourceLine" id="cb61-4" title="4">  <span class="fu">==&gt;</span>      <span class="dv">16</span></a></code></pre></div>
 <!--
 ```haskell
 square   ==>   *   ==>   *   ==>  16
@@ -1037,24 +1035,24 @@ square   ==>   *   ==>   *   ==>  16
 -->
 <p><img src="img/square2.svg" /></p>
 <p>As another example, consider the function <code>f</code> below and its evaluation.</p>
-<div class="sourceCode" id="cb62"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb62-1" data-line-number="1"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb62-2" data-line-number="2">f i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> i</a></code></pre></div>
-<div class="sourceCode" id="cb63"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb63-1" data-line-number="1">                  _______shared________</a>
-<a class="sourceLine" id="cb63-2" data-line-number="2">                 <span class="fu">|</span>                     <span class="fu">|</span></a>
-<a class="sourceLine" id="cb63-3" data-line-number="3">f (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="kw">if</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb63-4" data-line-number="4">        <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dv">2</span><span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb63-5" data-line-number="5">        <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dt">False</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb63-6" data-line-number="6">        <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb62"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb62-1" title="1"><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb62-2" title="2">f i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> i</a></code></pre></div>
+<div class="sourceCode" id="cb63"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb63-1" title="1">                  _______shared________</a>
+<a class="sourceLine" id="cb63-2" title="2">                 <span class="fu">|</span>                     <span class="fu">|</span></a>
+<a class="sourceLine" id="cb63-3" title="3">f (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="kw">if</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb63-4" title="4">        <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dv">2</span><span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb63-5" title="5">        <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dt">False</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb63-6" title="6">        <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
 <p>Haskell does not compute <code>1+1</code> twice because it was named, and the name was used twice. We can contrast this with another function that takes two arguments:</p>
-<div class="sourceCode" id="cb64"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb64-1" data-line-number="1"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb64-2" data-line-number="2">g i j <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> j</a></code></pre></div>
-<div class="sourceCode" id="cb65"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb65-1" data-line-number="1">                        ______no sharing_____</a>
-<a class="sourceLine" id="cb65-2" data-line-number="2">                       <span class="fu">|</span>                     <span class="fu">|</span></a>
-<a class="sourceLine" id="cb65-3" data-line-number="3">g (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="kw">if</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb65-4" data-line-number="4">              <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dv">2</span><span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb65-5" data-line-number="5">              <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dt">False</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb65-6" data-line-number="6">              <span class="fu">==&gt;</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb65-7" data-line-number="7">              <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb64"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb64-1" title="1"><span class="ot">g ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb64-2" title="2">g i j <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> j</a></code></pre></div>
+<div class="sourceCode" id="cb65"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb65-1" title="1">                        ______no sharing_____</a>
+<a class="sourceLine" id="cb65-2" title="2">                       <span class="fu">|</span>                     <span class="fu">|</span></a>
+<a class="sourceLine" id="cb65-3" title="3">g (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>) <span class="fu">==&gt;</span> <span class="kw">if</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb65-4" title="4">              <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dv">2</span><span class="fu">&gt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb65-5" title="5">              <span class="fu">==&gt;</span> <span class="kw">if</span> <span class="dt">False</span> <span class="kw">then</span> <span class="dv">10</span> <span class="kw">else</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb65-6" title="6">              <span class="fu">==&gt;</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb65-7" title="7">              <span class="fu">==&gt;</span> <span class="dv">2</span></a></code></pre></div>
 <p>Here we have two different names for equivalent expressions, and Haskell doesn’t magically share them. Automatically sharing equivalent expressions is an optimization called <em>Common Subexpression Elimination (CSE)</em>. You can learn a bit more <a href="https://wiki.haskell.org/GHC_optimisations#Common_subexpression_elimination">CSE and Haskell here</a>.</p>
 <p>You can name things via</p>
 <ul>
@@ -1065,353 +1063,353 @@ square   ==>   *   ==>   *   ==>  16
 <p>Combined with laziness, sharing means that <em>a name gets evaluated at most once</em>.</p>
 <h3 id="further-examples"><span class="header-section-number">10.4.3</span> Further Examples</h3>
 <p>You’ll find below a slightly contrived recursive definition of the function <code>even</code>. It will illustrate the concepts of forcing and sharing.</p>
-<div class="sourceCode" id="cb66"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb66-1" data-line-number="1">not<span class="ot"> ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb66-2" data-line-number="2">not <span class="dt">True</span> <span class="fu">=</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb66-3" data-line-number="3">not <span class="dt">False</span> <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb66-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb66-5" data-line-number="5"><span class="ot">(||) ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb66-6" data-line-number="6"><span class="dt">True</span> <span class="fu">||</span> _ <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb66-7" data-line-number="7">_    <span class="fu">||</span> x <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb66-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb66-9" data-line-number="9">even<span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb66-10" data-line-number="10">even x  <span class="fu">=</span>  x <span class="fu">==</span> <span class="dv">0</span>  <span class="fu">||</span>  not (even (x<span class="fu">-</span><span class="dv">1</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb66"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb66-1" title="1"><span class="fu">not</span><span class="ot"> ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb66-2" title="2"><span class="fu">not</span> <span class="dt">True</span> <span class="fu">=</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb66-3" title="3"><span class="fu">not</span> <span class="dt">False</span> <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb66-4" title="4"></a>
+<a class="sourceLine" id="cb66-5" title="5"><span class="ot">(||) ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb66-6" title="6"><span class="dt">True</span> <span class="fu">||</span> _ <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb66-7" title="7">_    <span class="fu">||</span> x <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb66-8" title="8"></a>
+<a class="sourceLine" id="cb66-9" title="9"><span class="fu">even</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb66-10" title="10"><span class="fu">even</span> x  <span class="fu">=</span>  x <span class="fu">==</span> <span class="dv">0</span>  <span class="fu">||</span>  <span class="fu">not</span> (<span class="fu">even</span> (x<span class="fu">-</span><span class="dv">1</span>))</a></code></pre></div>
 <p>Firstly, note that <code>||</code> forces its left argument, but not its right argument. (In other words, <code>||</code> is <em>strict in its left argument</em>.) This is because we only need to evaluate the left argument of <code>||</code> in order to know which equation applies. This means by extension that <code>even</code> forces its first argument:</p>
 <ul>
 <li><code>||</code> forces <code>x==0</code></li>
 <li><code>x==0</code> forces <code>x</code></li>
 </ul>
 <p>Now let’s evaluate the expression <code>even 2</code> to WHNF.</p>
-<div class="sourceCode" id="cb67"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb67-1" data-line-number="1">even <span class="dv">2</span></a>
-<a class="sourceLine" id="cb67-2" data-line-number="2"><span class="fu">==&gt;</span> <span class="dv">2</span> <span class="fu">==</span> <span class="dv">0</span>  <span class="fu">||</span>  not (even (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                    <span class="co">-- apply definition of even</span></a>
-<a class="sourceLine" id="cb67-3" data-line-number="3"><span class="fu">==&gt;</span> <span class="dt">False</span>   <span class="fu">||</span>  not (even (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                    <span class="co">-- || forces its first argument</span></a>
-<a class="sourceLine" id="cb67-4" data-line-number="4"><span class="fu">==&gt;</span> not (even (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                                <span class="co">-- second equation of ||</span></a>
-<a class="sourceLine" id="cb67-5" data-line-number="5"><span class="fu">==&gt;</span> not ((<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>) <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> not (even ((<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>)<span class="fu">-</span><span class="dv">1</span>)))        <span class="co">-- not forces its argument: apply definition of even</span></a>
-<a class="sourceLine" id="cb67-6" data-line-number="6"><span class="fu">==&gt;</span> not (  <span class="dv">1</span>   <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> not (even (  <span class="dv">1</span>  <span class="fu">-</span><span class="dv">1</span>)))        <span class="co">-- note sharing!</span></a>
-<a class="sourceLine" id="cb67-7" data-line-number="7"><span class="fu">==&gt;</span> not (  <span class="dt">False</span>    <span class="fu">||</span> not (even (<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)))</a>
-<a class="sourceLine" id="cb67-8" data-line-number="8"><span class="fu">==&gt;</span> not (not (even (<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)))</a>
-<a class="sourceLine" id="cb67-9" data-line-number="9"><span class="fu">==&gt;</span> not (not ((<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>) <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> not (even ((<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)<span class="fu">-</span><span class="dv">1</span>))))</a>
-<a class="sourceLine" id="cb67-10" data-line-number="10"><span class="fu">==&gt;</span> not (not (  <span class="dv">0</span>   <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> not (even (  <span class="dv">0</span>  <span class="fu">-</span><span class="dv">1</span>))))  <span class="co">-- (sharing)</span></a>
-<a class="sourceLine" id="cb67-11" data-line-number="11"><span class="fu">==&gt;</span> not (not (   <span class="dt">True</span>    <span class="fu">||</span> not (even (<span class="dv">0</span><span class="fu">-</span><span class="dv">1</span>))))</a>
-<a class="sourceLine" id="cb67-12" data-line-number="12"><span class="fu">==&gt;</span> not (not <span class="dt">True</span>)</a>
-<a class="sourceLine" id="cb67-13" data-line-number="13"><span class="fu">==&gt;</span> not <span class="dt">False</span></a>
-<a class="sourceLine" id="cb67-14" data-line-number="14"><span class="fu">==&gt;</span> <span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb67"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb67-1" title="1"><span class="fu">even</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb67-2" title="2"><span class="fu">==&gt;</span> <span class="dv">2</span> <span class="fu">==</span> <span class="dv">0</span>  <span class="fu">||</span>  <span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                    <span class="co">-- apply definition of even</span></a>
+<a class="sourceLine" id="cb67-3" title="3"><span class="fu">==&gt;</span> <span class="dt">False</span>   <span class="fu">||</span>  <span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                    <span class="co">-- || forces its first argument</span></a>
+<a class="sourceLine" id="cb67-4" title="4"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>))                                <span class="co">-- second equation of ||</span></a>
+<a class="sourceLine" id="cb67-5" title="5"><span class="fu">==&gt;</span> <span class="fu">not</span> ((<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>) <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> ((<span class="dv">2</span><span class="fu">-</span><span class="dv">1</span>)<span class="fu">-</span><span class="dv">1</span>)))        <span class="co">-- not forces its argument: apply definition of even</span></a>
+<a class="sourceLine" id="cb67-6" title="6"><span class="fu">==&gt;</span> <span class="fu">not</span> (  <span class="dv">1</span>   <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> (  <span class="dv">1</span>  <span class="fu">-</span><span class="dv">1</span>)))        <span class="co">-- note sharing!</span></a>
+<a class="sourceLine" id="cb67-7" title="7"><span class="fu">==&gt;</span> <span class="fu">not</span> (  <span class="dt">False</span>    <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)))</a>
+<a class="sourceLine" id="cb67-8" title="8"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)))</a>
+<a class="sourceLine" id="cb67-9" title="9"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">not</span> ((<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>) <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> ((<span class="dv">1</span><span class="fu">-</span><span class="dv">1</span>)<span class="fu">-</span><span class="dv">1</span>))))</a>
+<a class="sourceLine" id="cb67-10" title="10"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">not</span> (  <span class="dv">0</span>   <span class="fu">==</span> <span class="dv">0</span> <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> (  <span class="dv">0</span>  <span class="fu">-</span><span class="dv">1</span>))))  <span class="co">-- (sharing)</span></a>
+<a class="sourceLine" id="cb67-11" title="11"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">not</span> (   <span class="dt">True</span>    <span class="fu">||</span> <span class="fu">not</span> (<span class="fu">even</span> (<span class="dv">0</span><span class="fu">-</span><span class="dv">1</span>))))</a>
+<a class="sourceLine" id="cb67-12" title="12"><span class="fu">==&gt;</span> <span class="fu">not</span> (<span class="fu">not</span> <span class="dt">True</span>)</a>
+<a class="sourceLine" id="cb67-13" title="13"><span class="fu">==&gt;</span> <span class="fu">not</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb67-14" title="14"><span class="fu">==&gt;</span> <span class="dt">True</span></a></code></pre></div>
 <p>Note that with this alternate definition <code>even</code> would not have worked. Can you tell why?</p>
-<div class="sourceCode" id="cb68"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb68-1" data-line-number="1">even&#39; x <span class="fu">=</span>  not (even&#39; (x<span class="fu">-</span><span class="dv">1</span>))  <span class="fu">||</span>  x <span class="fu">==</span> <span class="dv">0</span></a></code></pre></div>
+<div class="sourceCode" id="cb68"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb68-1" title="1">even&#39; x <span class="fu">=</span>  <span class="fu">not</span> (even&#39; (x<span class="fu">-</span><span class="dv">1</span>))  <span class="fu">||</span>  x <span class="fu">==</span> <span class="dv">0</span></a></code></pre></div>
 <p>Now we can really understand what’s going on in the infinite list example from earlier. Let’s use these definitions:</p>
-<div class="sourceCode" id="cb69"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb69-1" data-line-number="1">head (x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
-<a class="sourceLine" id="cb69-2" data-line-number="2">head [] <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb69-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb69-4" data-line-number="4">filter p [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb69-5" data-line-number="5">filter p (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">if</span> p x</a>
-<a class="sourceLine" id="cb69-6" data-line-number="6">                  <span class="kw">then</span> x <span class="fu">:</span> filter p xs</a>
-<a class="sourceLine" id="cb69-7" data-line-number="7">                  <span class="kw">else</span> filter p xs</a>
-<a class="sourceLine" id="cb69-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb69-9" data-line-number="9">map f [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb69-10" data-line-number="10">map f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> map f xs</a>
-<a class="sourceLine" id="cb69-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb69-12" data-line-number="12"><span class="co">-- [0..] is syntax sugar for enumFrom 0</span></a>
-<a class="sourceLine" id="cb69-13" data-line-number="13">enumFrom n <span class="fu">=</span> n <span class="fu">:</span> enumFrom (n<span class="fu">+</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb69"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb69-1" title="1"><span class="fu">head</span> (x<span class="fu">:</span>_) <span class="fu">=</span> x</a>
+<a class="sourceLine" id="cb69-2" title="2"><span class="fu">head</span> [] <span class="fu">=</span> <span class="fu">-</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb69-3" title="3"></a>
+<a class="sourceLine" id="cb69-4" title="4"><span class="fu">filter</span> p [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb69-5" title="5"><span class="fu">filter</span> p (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">if</span> p x</a>
+<a class="sourceLine" id="cb69-6" title="6">                  <span class="kw">then</span> x <span class="fu">:</span> <span class="fu">filter</span> p xs</a>
+<a class="sourceLine" id="cb69-7" title="7">                  <span class="kw">else</span> <span class="fu">filter</span> p xs</a>
+<a class="sourceLine" id="cb69-8" title="8"></a>
+<a class="sourceLine" id="cb69-9" title="9"><span class="fu">map</span> f [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb69-10" title="10"><span class="fu">map</span> f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> <span class="fu">map</span> f xs</a>
+<a class="sourceLine" id="cb69-11" title="11"></a>
+<a class="sourceLine" id="cb69-12" title="12"><span class="co">-- [0..] is syntax sugar for enumFrom 0</span></a>
+<a class="sourceLine" id="cb69-13" title="13"><span class="fu">enumFrom</span> n <span class="fu">=</span> n <span class="fu">:</span> <span class="fu">enumFrom</span> (n<span class="fu">+</span><span class="dv">1</span>)</a></code></pre></div>
 <p>And here we go:</p>
-<div class="sourceCode" id="cb70"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb70-1" data-line-number="1">    head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-2" data-line-number="2"><span class="fu">===</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) (enumFrom <span class="dv">0</span>)))</a>
-<a class="sourceLine" id="cb70-3" data-line-number="3"><span class="co">-- head forces filter, which forces map, which forces enumFrom. We apply the definition of enumFrom.</span></a>
-<a class="sourceLine" id="cb70-4" data-line-number="4"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">0</span><span class="fu">:</span>[<span class="dv">1</span><span class="fu">..</span>])))</a>
-<a class="sourceLine" id="cb70-5" data-line-number="5"><span class="co">-- head forces filter, which forces map. We apply the second equation of map.</span></a>
-<a class="sourceLine" id="cb70-6" data-line-number="6"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) ((<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>) <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-7" data-line-number="7"><span class="co">-- head forces filter. We apply the second equation of filter</span></a>
-<a class="sourceLine" id="cb70-8" data-line-number="8"><span class="fu">==&gt;</span> head (<span class="kw">if</span> ((<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>)<span class="fu">&gt;</span><span class="dv">100</span>)</a>
-<a class="sourceLine" id="cb70-9" data-line-number="9">          <span class="kw">then</span> (<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>) <span class="fu">:</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
-<a class="sourceLine" id="cb70-10" data-line-number="10">          <span class="kw">else</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-11" data-line-number="11"><span class="co">-- head forces if, if forces &gt;, &gt; forces ^. Note sharing!</span></a>
-<a class="sourceLine" id="cb70-12" data-line-number="12"><span class="fu">==&gt;</span> head (<span class="kw">if</span> (<span class="dv">1</span><span class="fu">&gt;</span><span class="dv">100</span>)</a>
-<a class="sourceLine" id="cb70-13" data-line-number="13">          <span class="kw">then</span> <span class="dv">1</span> <span class="fu">:</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
-<a class="sourceLine" id="cb70-14" data-line-number="14">          <span class="kw">else</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-15" data-line-number="15"><span class="co">-- head forces if, if forces &gt;</span></a>
-<a class="sourceLine" id="cb70-16" data-line-number="16"><span class="fu">==&gt;</span> head (<span class="kw">if</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb70-17" data-line-number="17">          <span class="kw">then</span> <span class="dv">1</span> <span class="fu">:</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
-<a class="sourceLine" id="cb70-18" data-line-number="18">          <span class="kw">else</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-19" data-line-number="19"><span class="co">-- apply definition of if</span></a>
-<a class="sourceLine" id="cb70-20" data-line-number="20"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-21" data-line-number="21"><span class="co">-- let&#39;s take slightly bigger steps now</span></a>
-<a class="sourceLine" id="cb70-22" data-line-number="22"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span><span class="fu">..</span>])))</a>
-<a class="sourceLine" id="cb70-23" data-line-number="23"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) ((<span class="dv">3</span><span class="fu">^</span><span class="dv">1</span>) <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-24" data-line-number="24"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">3</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-25" data-line-number="25"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-26" data-line-number="26"><span class="co">-- and even bigger steps now</span></a>
-<a class="sourceLine" id="cb70-27" data-line-number="27"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">9</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">3</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-28" data-line-number="28"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">27</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">4</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-29" data-line-number="29"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">81</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">5</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-30" data-line-number="30"><span class="fu">==&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">243</span> <span class="fu">:</span> map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-31" data-line-number="31"><span class="fu">==&gt;</span> head (<span class="dv">243</span> <span class="fu">:</span> filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb70-32" data-line-number="32"><span class="fu">==&gt;</span> <span class="dv">243</span></a></code></pre></div>
+<div class="sourceCode" id="cb70"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb70-1" title="1">    <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-2" title="2"><span class="fu">===</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) (<span class="fu">enumFrom</span> <span class="dv">0</span>)))</a>
+<a class="sourceLine" id="cb70-3" title="3"><span class="co">-- head forces filter, which forces map, which forces enumFrom. We apply the definition of enumFrom.</span></a>
+<a class="sourceLine" id="cb70-4" title="4"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">0</span><span class="fu">:</span>[<span class="dv">1</span><span class="fu">..</span>])))</a>
+<a class="sourceLine" id="cb70-5" title="5"><span class="co">-- head forces filter, which forces map. We apply the second equation of map.</span></a>
+<a class="sourceLine" id="cb70-6" title="6"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) ((<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>) <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-7" title="7"><span class="co">-- head forces filter. We apply the second equation of filter</span></a>
+<a class="sourceLine" id="cb70-8" title="8"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> ((<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>)<span class="fu">&gt;</span><span class="dv">100</span>)</a>
+<a class="sourceLine" id="cb70-9" title="9">          <span class="kw">then</span> (<span class="dv">3</span><span class="fu">^</span><span class="dv">0</span>) <span class="fu">:</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
+<a class="sourceLine" id="cb70-10" title="10">          <span class="kw">else</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-11" title="11"><span class="co">-- head forces if, if forces &gt;, &gt; forces ^. Note sharing!</span></a>
+<a class="sourceLine" id="cb70-12" title="12"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> (<span class="dv">1</span><span class="fu">&gt;</span><span class="dv">100</span>)</a>
+<a class="sourceLine" id="cb70-13" title="13">          <span class="kw">then</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
+<a class="sourceLine" id="cb70-14" title="14">          <span class="kw">else</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-15" title="15"><span class="co">-- head forces if, if forces &gt;</span></a>
+<a class="sourceLine" id="cb70-16" title="16"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb70-17" title="17">          <span class="kw">then</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>])</a>
+<a class="sourceLine" id="cb70-18" title="18">          <span class="kw">else</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-19" title="19"><span class="co">-- apply definition of if</span></a>
+<a class="sourceLine" id="cb70-20" title="20"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">1</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-21" title="21"><span class="co">-- let&#39;s take slightly bigger steps now</span></a>
+<a class="sourceLine" id="cb70-22" title="22"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span><span class="fu">..</span>])))</a>
+<a class="sourceLine" id="cb70-23" title="23"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) ((<span class="dv">3</span><span class="fu">^</span><span class="dv">1</span>) <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-24" title="24"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">3</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-25" title="25"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">2</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-26" title="26"><span class="co">-- and even bigger steps now</span></a>
+<a class="sourceLine" id="cb70-27" title="27"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">9</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">3</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-28" title="28"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">27</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">4</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-29" title="29"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">81</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">5</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-30" title="30"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="dv">243</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-31" title="31"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="dv">243</span> <span class="fu">:</span> <span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (<span class="dv">3</span><span class="fu">^</span>) [<span class="dv">6</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb70-32" title="32"><span class="fu">==&gt;</span> <span class="dv">243</span></a></code></pre></div>
 <p>Whew.</p>
 <h2 id="working-with-infinite-lists"><span class="header-section-number">10.5</span> Working with Infinite Lists</h2>
 <p>Functions that work with lists often have the best performance when they’re written in such a way that they utilize laziness. One way to try to accomplish this is to write list-handling functions that work well with infinite lists.</p>
 <p>To write a function that transforms an infinite list, you need to write a function that only looks at a limited prefix of the input list, then outputs a <code>(:)</code> constructor, and then recurses. Here’s a first example.</p>
-<div class="sourceCode" id="cb71"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb71-1" data-line-number="1"><span class="ot">everySecond ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb71-2" data-line-number="2">everySecond [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb71-3" data-line-number="3">everySecond (x<span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">:</span> everySecond xs</a></code></pre></div>
-<div class="sourceCode" id="cb72"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb72-1" data-line-number="1">take <span class="dv">10</span> (everySecond [<span class="dv">0</span><span class="fu">..</span>])  <span class="fu">==&gt;</span>  [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>,<span class="dv">8</span>,<span class="dv">10</span>,<span class="dv">12</span>,<span class="dv">14</span>,<span class="dv">16</span>,<span class="dv">18</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb71"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb71-1" title="1"><span class="ot">everySecond ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb71-2" title="2">everySecond [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb71-3" title="3">everySecond (x<span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">:</span> everySecond xs</a></code></pre></div>
+<div class="sourceCode" id="cb72"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb72-1" title="1"><span class="fu">take</span> <span class="dv">10</span> (everySecond [<span class="dv">0</span><span class="fu">..</span>])  <span class="fu">==&gt;</span>  [<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>,<span class="dv">8</span>,<span class="dv">10</span>,<span class="dv">12</span>,<span class="dv">14</span>,<span class="dv">16</span>,<span class="dv">18</span>]</a></code></pre></div>
 <p>A good heuristic for writing functions that work well with infinite lists is: can the <code>head</code> of the result be evaluated cheaply? Here are two examples of functions that don’t work with infinite inputs. In the case of <code>mapTailRecursive</code>, the problem is that it needs to process the whole input before being in WHNF. In the case of <code>myDrop</code>, the problem is that it uses the function <code>length</code>, doesn’t work for infinite lists since it tries to iterate until the end of the list.</p>
-<div class="sourceCode" id="cb73"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb73-1" data-line-number="1">map<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb73-2" data-line-number="2">map _ []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb73-3" data-line-number="3">map f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> map f xs</a>
-<a class="sourceLine" id="cb73-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb73-5" data-line-number="5"><span class="ot">mapTailRecursive ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb73-6" data-line-number="6">mapTailRecursive f xs <span class="fu">=</span> go xs []</a>
-<a class="sourceLine" id="cb73-7" data-line-number="7">    <span class="kw">where</span> go (x<span class="fu">:</span>xs) res <span class="fu">=</span> go xs (res<span class="fu">++</span>[f x])</a>
-<a class="sourceLine" id="cb73-8" data-line-number="8">          go []     res <span class="fu">=</span> res</a></code></pre></div>
-<div class="sourceCode" id="cb74"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb74-1" data-line-number="1">head (map inc [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> head (inc <span class="dv">0</span> <span class="fu">:</span> map inc [<span class="dv">1</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> inc <span class="dv">0</span> <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb74-2" data-line-number="2">head (mapTailRecursive inc [<span class="dv">0</span><span class="fu">..</span>])</a>
-<a class="sourceLine" id="cb74-3" data-line-number="3">  <span class="fu">==&gt;</span> head (go [<span class="dv">0</span><span class="fu">..</span>] [])</a>
-<a class="sourceLine" id="cb74-4" data-line-number="4">  <span class="fu">==&gt;</span> head (go [<span class="dv">1</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]))</a>
-<a class="sourceLine" id="cb74-5" data-line-number="5">  <span class="fu">==&gt;</span> head (go [<span class="dv">2</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]<span class="fu">++</span>[inc <span class="dv">1</span>]))</a>
-<a class="sourceLine" id="cb74-6" data-line-number="6">  <span class="fu">==&gt;</span> head (go [<span class="dv">3</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]<span class="fu">++</span>[inc <span class="dv">1</span>]<span class="fu">++</span>[inc <span class="dv">2</span>]))</a>
-<a class="sourceLine" id="cb74-7" data-line-number="7">  <span class="co">--  never terminates</span></a></code></pre></div>
-<div class="sourceCode" id="cb75"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb75-1" data-line-number="1">drop<span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb75-2" data-line-number="2">drop <span class="dv">0</span> xs <span class="fu">=</span> xs</a>
-<a class="sourceLine" id="cb75-3" data-line-number="3">drop _ [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb75-4" data-line-number="4">drop n (x<span class="fu">:</span>xs) <span class="fu">=</span> drop (n<span class="fu">-</span><span class="dv">1</span>) xs</a>
-<a class="sourceLine" id="cb75-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb75-6" data-line-number="6"><span class="ot">myDrop ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb75-7" data-line-number="7">myDrop <span class="dv">0</span> xs <span class="fu">=</span> xs</a>
-<a class="sourceLine" id="cb75-8" data-line-number="8">myDrop n xs <span class="fu">=</span> <span class="kw">if</span> n <span class="fu">&gt;</span> length xs <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (tail xs)</a></code></pre></div>
-<div class="sourceCode" id="cb76"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb76-1" data-line-number="1">head (drop <span class="dv">2</span> [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> head (drop <span class="dv">1</span> [<span class="dv">1</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> head (drop <span class="dv">0</span> [<span class="dv">2</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> head [<span class="dv">2</span><span class="fu">..</span>] <span class="fu">==&gt;</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb76-2" data-line-number="2">head (myDrop <span class="dv">2</span> [<span class="dv">0</span><span class="fu">..</span>])</a>
-<a class="sourceLine" id="cb76-3" data-line-number="3">  <span class="fu">==&gt;</span> head (<span class="kw">if</span> n <span class="fu">&gt;</span> length [<span class="dv">0</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (tail [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb76-4" data-line-number="4">  <span class="fu">==&gt;</span> head (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+</span>length [<span class="dv">1</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (tail [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb76-5" data-line-number="5">  <span class="fu">==&gt;</span> head (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+</span>length [<span class="dv">2</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (tail [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb76-6" data-line-number="6">  <span class="fu">==&gt;</span> head (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+</span>length [<span class="dv">3</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (tail [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb76-7" data-line-number="7">  <span class="co">--  never terminates</span></a></code></pre></div>
+<div class="sourceCode" id="cb73"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb73-1" title="1"><span class="fu">map</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb73-2" title="2"><span class="fu">map</span> _ []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb73-3" title="3"><span class="fu">map</span> f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> <span class="fu">map</span> f xs</a>
+<a class="sourceLine" id="cb73-4" title="4"></a>
+<a class="sourceLine" id="cb73-5" title="5"><span class="ot">mapTailRecursive ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb73-6" title="6">mapTailRecursive f xs <span class="fu">=</span> go xs []</a>
+<a class="sourceLine" id="cb73-7" title="7">    <span class="kw">where</span> go (x<span class="fu">:</span>xs) res <span class="fu">=</span> go xs (res<span class="fu">++</span>[f x])</a>
+<a class="sourceLine" id="cb73-8" title="8">          go []     res <span class="fu">=</span> res</a></code></pre></div>
+<div class="sourceCode" id="cb74"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb74-1" title="1"><span class="fu">head</span> (<span class="fu">map</span> inc [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="fu">head</span> (inc <span class="dv">0</span> <span class="fu">:</span> <span class="fu">map</span> inc [<span class="dv">1</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> inc <span class="dv">0</span> <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb74-2" title="2"><span class="fu">head</span> (mapTailRecursive inc [<span class="dv">0</span><span class="fu">..</span>])</a>
+<a class="sourceLine" id="cb74-3" title="3">  <span class="fu">==&gt;</span> <span class="fu">head</span> (go [<span class="dv">0</span><span class="fu">..</span>] [])</a>
+<a class="sourceLine" id="cb74-4" title="4">  <span class="fu">==&gt;</span> <span class="fu">head</span> (go [<span class="dv">1</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]))</a>
+<a class="sourceLine" id="cb74-5" title="5">  <span class="fu">==&gt;</span> <span class="fu">head</span> (go [<span class="dv">2</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]<span class="fu">++</span>[inc <span class="dv">1</span>]))</a>
+<a class="sourceLine" id="cb74-6" title="6">  <span class="fu">==&gt;</span> <span class="fu">head</span> (go [<span class="dv">3</span><span class="fu">..</span>] ([]<span class="fu">++</span>[inc <span class="dv">0</span>]<span class="fu">++</span>[inc <span class="dv">1</span>]<span class="fu">++</span>[inc <span class="dv">2</span>]))</a>
+<a class="sourceLine" id="cb74-7" title="7">  <span class="co">--  never terminates</span></a></code></pre></div>
+<div class="sourceCode" id="cb75"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb75-1" title="1"><span class="fu">drop</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb75-2" title="2"><span class="fu">drop</span> <span class="dv">0</span> xs <span class="fu">=</span> xs</a>
+<a class="sourceLine" id="cb75-3" title="3"><span class="fu">drop</span> _ [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb75-4" title="4"><span class="fu">drop</span> n (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="fu">drop</span> (n<span class="fu">-</span><span class="dv">1</span>) xs</a>
+<a class="sourceLine" id="cb75-5" title="5"></a>
+<a class="sourceLine" id="cb75-6" title="6"><span class="ot">myDrop ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb75-7" title="7">myDrop <span class="dv">0</span> xs <span class="fu">=</span> xs</a>
+<a class="sourceLine" id="cb75-8" title="8">myDrop n xs <span class="fu">=</span> <span class="kw">if</span> n <span class="fu">&gt;</span> <span class="fu">length</span> xs <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (<span class="fu">tail</span> xs)</a></code></pre></div>
+<div class="sourceCode" id="cb76"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb76-1" title="1"><span class="fu">head</span> (<span class="fu">drop</span> <span class="dv">2</span> [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">drop</span> <span class="dv">1</span> [<span class="dv">1</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">drop</span> <span class="dv">0</span> [<span class="dv">2</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="fu">head</span> [<span class="dv">2</span><span class="fu">..</span>] <span class="fu">==&gt;</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb76-2" title="2"><span class="fu">head</span> (myDrop <span class="dv">2</span> [<span class="dv">0</span><span class="fu">..</span>])</a>
+<a class="sourceLine" id="cb76-3" title="3">  <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="fu">length</span> [<span class="dv">0</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (<span class="fu">tail</span> [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb76-4" title="4">  <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+length</span> [<span class="dv">1</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (<span class="fu">tail</span> [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb76-5" title="5">  <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+length</span> [<span class="dv">2</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (<span class="fu">tail</span> [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb76-6" title="6">  <span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="kw">if</span> n <span class="fu">&gt;</span> <span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+</span><span class="dv">1</span><span class="fu">+length</span> [<span class="dv">3</span><span class="fu">..</span>] <span class="kw">then</span> [] <span class="kw">else</span> myDrop (n<span class="fu">-</span><span class="dv">1</span>) (<span class="fu">tail</span> [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb76-7" title="7">  <span class="co">--  never terminates</span></a></code></pre></div>
 <p>Pretty much all the list functions in the standard library are written in this form, for example:</p>
-<div class="sourceCode" id="cb77"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb77-1" data-line-number="1">head (takeWhile (<span class="fu">&gt;=</span><span class="dv">0</span>) [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb77-2" data-line-number="2">head (concat (repeat [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])) <span class="fu">==&gt;</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb77-3" data-line-number="3">head (zip [<span class="dv">0</span><span class="fu">..</span>] [<span class="dv">2</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> (<span class="dv">0</span>,<span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb77-4" data-line-number="4">head (filter even [<span class="dv">3</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
+<div class="sourceCode" id="cb77"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb77-1" title="1"><span class="fu">head</span> (<span class="fu">takeWhile</span> (<span class="fu">&gt;=</span><span class="dv">0</span>) [<span class="dv">0</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb77-2" title="2"><span class="fu">head</span> (<span class="fu">concat</span> (<span class="fu">repeat</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])) <span class="fu">==&gt;</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb77-3" title="3"><span class="fu">head</span> (<span class="fu">zip</span> [<span class="dv">0</span><span class="fu">..</span>] [<span class="dv">2</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> (<span class="dv">0</span>,<span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb77-4" title="4"><span class="fu">head</span> (<span class="fu">filter</span> <span class="fu">even</span> [<span class="dv">3</span><span class="fu">..</span>]) <span class="fu">==&gt;</span> <span class="dv">4</span></a></code></pre></div>
 <h2 id="interlude-adding-strictness"><span class="header-section-number">10.6</span> Interlude: Adding Strictness</h2>
 <p>Remember <code>foldr</code> from part 1? Let’s have a look at its cousin <code>foldl</code>. Here’s the definition of <code>foldl</code> for lists (it’s actually part of the <code>Foldable</code> typeclass and so works for various other types too). While <code>foldr</code> processes a list right-to-left, <code>foldl</code> processes a list left-to-right. To be a bit more exact, <code>foldr</code> <em>associates to the right</em> while <code>foldl</code> <em>associates to the left</em>. Note the difference in the next example:</p>
-<div class="sourceCode" id="cb78"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb78-1" data-line-number="1">foldr (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dv">1</span><span class="fu">+</span>(<span class="dv">2</span><span class="fu">+</span>(<span class="dv">3</span><span class="fu">+</span><span class="dv">0</span>))</a>
-<a class="sourceLine" id="cb78-2" data-line-number="2">foldl (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb78"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb78-1" title="1"><span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dv">1</span><span class="fu">+</span>(<span class="dv">2</span><span class="fu">+</span>(<span class="dv">3</span><span class="fu">+</span><span class="dv">0</span>))</a>
+<a class="sourceLine" id="cb78-2" title="2"><span class="fu">foldl</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a></code></pre></div>
 <p>Here are the definitions of <code>foldl</code> and <code>foldr</code>:</p>
-<div class="sourceCode" id="cb79"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb79-1" data-line-number="1">foldl<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb79-2" data-line-number="2">foldl f z [] <span class="fu">=</span> z</a>
-<a class="sourceLine" id="cb79-3" data-line-number="3">foldl f z (x<span class="fu">:</span>xs) <span class="fu">=</span> foldl f (f z x) xs</a></code></pre></div>
-<div class="sourceCode" id="cb80"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb80-1" data-line-number="1">foldr<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> b</a>
-<a class="sourceLine" id="cb80-2" data-line-number="2">foldr f y []     <span class="fu">=</span> y</a>
-<a class="sourceLine" id="cb80-3" data-line-number="3">foldr f y (x<span class="fu">:</span>xs) <span class="fu">=</span> f x (foldr f y xs)</a></code></pre></div>
+<div class="sourceCode" id="cb79"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb79-1" title="1"><span class="fu">foldl</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb79-2" title="2"><span class="fu">foldl</span> f z [] <span class="fu">=</span> z</a>
+<a class="sourceLine" id="cb79-3" title="3"><span class="fu">foldl</span> f z (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="fu">foldl</span> f (f z x) xs</a></code></pre></div>
+<div class="sourceCode" id="cb80"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb80-1" title="1"><span class="fu">foldr</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> b</a>
+<a class="sourceLine" id="cb80-2" title="2"><span class="fu">foldr</span> f y []     <span class="fu">=</span> y</a>
+<a class="sourceLine" id="cb80-3" title="3"><span class="fu">foldr</span> f y (x<span class="fu">:</span>xs) <span class="fu">=</span> f x (<span class="fu">foldr</span> f y xs)</a></code></pre></div>
 <p>As <code>foldr f y (x:xs) ==&gt; f x (foldr f y xs)</code>, it enables lazy evaluation to focus on <code>f</code> on the second step. Hence, <code>foldr</code> works nicely with lazy or short-circuiting operations:</p>
-<div class="sourceCode" id="cb81"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb81-1" data-line-number="1">    foldr (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>,<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb81-2" data-line-number="2"><span class="fu">==&gt;</span> <span class="dt">False</span> <span class="fu">&amp;&amp;</span> (foldr (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>])</a>
-<a class="sourceLine" id="cb81-3" data-line-number="3"><span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
-<div class="sourceCode" id="cb82"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb82-1" data-line-number="1">    head (foldr (<span class="fu">++</span>) [] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
-<a class="sourceLine" id="cb82-2" data-line-number="2"><span class="fu">==&gt;</span> head (<span class="st">&quot;Hello&quot;</span> <span class="fu">++</span> (foldr (<span class="fu">++</span>) [] [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>]))</a>
-<a class="sourceLine" id="cb82-3" data-line-number="3"><span class="fu">==&gt;</span> head (<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(<span class="st">&quot;ello&quot;</span> <span class="fu">++</span> (foldr (<span class="fu">++</span>) [] [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])))</a>
-<a class="sourceLine" id="cb82-4" data-line-number="4"><span class="fu">==&gt;</span> <span class="ch">&#39;H&#39;</span></a></code></pre></div>
+<div class="sourceCode" id="cb81"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb81-1" title="1">    <span class="fu">foldr</span> (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>,<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb81-2" title="2"><span class="fu">==&gt;</span> <span class="dt">False</span> <span class="fu">&amp;&amp;</span> (<span class="fu">foldr</span> (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>])</a>
+<a class="sourceLine" id="cb81-3" title="3"><span class="fu">==&gt;</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb82"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb82-1" title="1">    <span class="fu">head</span> (<span class="fu">foldr</span> (<span class="fu">++</span>) [] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
+<a class="sourceLine" id="cb82-2" title="2"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="st">&quot;Hello&quot;</span> <span class="fu">++</span> (<span class="fu">foldr</span> (<span class="fu">++</span>) [] [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>]))</a>
+<a class="sourceLine" id="cb82-3" title="3"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(<span class="st">&quot;ello&quot;</span> <span class="fu">++</span> (<span class="fu">foldr</span> (<span class="fu">++</span>) [] [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])))</a>
+<a class="sourceLine" id="cb82-4" title="4"><span class="fu">==&gt;</span> <span class="ch">&#39;H&#39;</span></a></code></pre></div>
 <p>However <code>foldl</code> needs to process the whole list in order to produce a (WHNF) value. The reason is that <code>foldl</code> remains in the leftmost-outermost position for as long as its list argument remains non-empty. This makes <code>foldl</code> the priority for lazy evaluation. Only after the list becomes empty does the evaluation proceed into simplifying the folded values.</p>
-<div class="sourceCode" id="cb83"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb83-1" data-line-number="1">    foldl (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>,<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb83-2" data-line-number="2"><span class="fu">==&gt;</span> foldl (<span class="fu">&amp;&amp;</span>) (<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>) [<span class="dt">False</span>,<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb83-3" data-line-number="3"><span class="fu">==&gt;</span> foldl (<span class="fu">&amp;&amp;</span>) ((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>) [<span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb83-4" data-line-number="4"><span class="fu">==&gt;</span> foldl (<span class="fu">&amp;&amp;</span>) (((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>) []</a>
-<a class="sourceLine" id="cb83-5" data-line-number="5"><span class="fu">==&gt;</span> ((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
-<a class="sourceLine" id="cb83-6" data-line-number="6"><span class="fu">==&gt;</span> (    <span class="dt">False</span>    <span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
-<a class="sourceLine" id="cb83-7" data-line-number="7"><span class="fu">==&gt;</span>              <span class="dt">False</span>    <span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
-<a class="sourceLine" id="cb83-8" data-line-number="8"><span class="fu">==&gt;</span>                      <span class="dt">False</span></a></code></pre></div>
-<div class="sourceCode" id="cb84"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb84-1" data-line-number="1">    head (foldl (<span class="fu">++</span>) [] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
-<a class="sourceLine" id="cb84-2" data-line-number="2"><span class="fu">==&gt;</span> head (foldl (<span class="fu">++</span>) ([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>) [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
-<a class="sourceLine" id="cb84-3" data-line-number="3"><span class="fu">==&gt;</span> head (foldl (<span class="fu">++</span>) (([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>) [<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
-<a class="sourceLine" id="cb84-4" data-line-number="4"><span class="fu">==&gt;</span> head (foldl (<span class="fu">++</span>) ((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>) [<span class="st">&quot;ipsum&quot;</span>])</a>
-<a class="sourceLine" id="cb84-5" data-line-number="5"><span class="fu">==&gt;</span> head (foldl (<span class="fu">++</span>) (((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>) [])</a>
-<a class="sourceLine" id="cb84-6" data-line-number="6"><span class="fu">==&gt;</span> head (((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-7" data-line-number="7"><span class="co">-- head forces the last ++, which forces the next-to-last ++, and so on</span></a>
-<a class="sourceLine" id="cb84-8" data-line-number="8"><span class="fu">==&gt;</span> head (((<span class="st">&quot;Hello&quot;</span><span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-9" data-line-number="9"><span class="co">-- same happens again</span></a>
-<a class="sourceLine" id="cb84-10" data-line-number="10"><span class="fu">==&gt;</span> head (((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(<span class="st">&quot;ello&quot;</span><span class="fu">++</span><span class="st">&quot;World&quot;</span>))<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-11" data-line-number="11"><span class="co">-- for clarity, let&#39;s drop the &quot;ello&quot;++&quot;World&quot; expression which isn&#39;t needed</span></a>
-<a class="sourceLine" id="cb84-12" data-line-number="12"><span class="fu">==&gt;</span> head (((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>__)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-13" data-line-number="13"><span class="co">-- now the next-to-last ++ can operate</span></a>
-<a class="sourceLine" id="cb84-14" data-line-number="14"><span class="fu">==&gt;</span> head ((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(__<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>))<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-15" data-line-number="15"><span class="co">-- let&#39;s drop the __++&quot;lorem&quot; expression</span></a>
-<a class="sourceLine" id="cb84-16" data-line-number="16"><span class="fu">==&gt;</span> head ((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>__)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
-<a class="sourceLine" id="cb84-17" data-line-number="17"><span class="co">-- now the last ++ can operate</span></a>
-<a class="sourceLine" id="cb84-18" data-line-number="18"><span class="fu">==&gt;</span> head (<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(__<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>))</a>
-<a class="sourceLine" id="cb84-19" data-line-number="19"><span class="fu">==&gt;</span> <span class="ch">&#39;H&#39;</span></a></code></pre></div>
+<div class="sourceCode" id="cb83"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb83-1" title="1">    <span class="fu">foldl</span> (<span class="fu">&amp;&amp;</span>) <span class="dt">True</span> [<span class="dt">False</span>,<span class="dt">False</span>,<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb83-2" title="2"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">&amp;&amp;</span>) (<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>) [<span class="dt">False</span>,<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb83-3" title="3"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">&amp;&amp;</span>) ((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>) [<span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb83-4" title="4"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">&amp;&amp;</span>) (((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>) []</a>
+<a class="sourceLine" id="cb83-5" title="5"><span class="fu">==&gt;</span> ((<span class="dt">True</span><span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
+<a class="sourceLine" id="cb83-6" title="6"><span class="fu">==&gt;</span> (    <span class="dt">False</span>    <span class="fu">&amp;&amp;</span><span class="dt">False</span>)<span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
+<a class="sourceLine" id="cb83-7" title="7"><span class="fu">==&gt;</span>              <span class="dt">False</span>    <span class="fu">&amp;&amp;</span><span class="dt">False</span></a>
+<a class="sourceLine" id="cb83-8" title="8"><span class="fu">==&gt;</span>                      <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb84"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb84-1" title="1">    <span class="fu">head</span> (<span class="fu">foldl</span> (<span class="fu">++</span>) [] [<span class="st">&quot;Hello&quot;</span>,<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
+<a class="sourceLine" id="cb84-2" title="2"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">foldl</span> (<span class="fu">++</span>) ([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>) [<span class="st">&quot;World&quot;</span>,<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
+<a class="sourceLine" id="cb84-3" title="3"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">foldl</span> (<span class="fu">++</span>) (([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>) [<span class="st">&quot;lorem&quot;</span>,<span class="st">&quot;ipsum&quot;</span>])</a>
+<a class="sourceLine" id="cb84-4" title="4"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">foldl</span> (<span class="fu">++</span>) ((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>) [<span class="st">&quot;ipsum&quot;</span>])</a>
+<a class="sourceLine" id="cb84-5" title="5"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="fu">foldl</span> (<span class="fu">++</span>) (((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>) [])</a>
+<a class="sourceLine" id="cb84-6" title="6"><span class="fu">==&gt;</span> <span class="fu">head</span> (((([]<span class="fu">++</span><span class="st">&quot;Hello&quot;</span>)<span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-7" title="7"><span class="co">-- head forces the last ++, which forces the next-to-last ++, and so on</span></a>
+<a class="sourceLine" id="cb84-8" title="8"><span class="fu">==&gt;</span> <span class="fu">head</span> (((<span class="st">&quot;Hello&quot;</span><span class="fu">++</span><span class="st">&quot;World&quot;</span>)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-9" title="9"><span class="co">-- same happens again</span></a>
+<a class="sourceLine" id="cb84-10" title="10"><span class="fu">==&gt;</span> <span class="fu">head</span> (((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(<span class="st">&quot;ello&quot;</span><span class="fu">++</span><span class="st">&quot;World&quot;</span>))<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-11" title="11"><span class="co">-- for clarity, let&#39;s drop the &quot;ello&quot;++&quot;World&quot; expression which isn&#39;t needed</span></a>
+<a class="sourceLine" id="cb84-12" title="12"><span class="fu">==&gt;</span> <span class="fu">head</span> (((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>__)<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-13" title="13"><span class="co">-- now the next-to-last ++ can operate</span></a>
+<a class="sourceLine" id="cb84-14" title="14"><span class="fu">==&gt;</span> <span class="fu">head</span> ((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(__<span class="fu">++</span><span class="st">&quot;lorem&quot;</span>))<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-15" title="15"><span class="co">-- let&#39;s drop the __++&quot;lorem&quot; expression</span></a>
+<a class="sourceLine" id="cb84-16" title="16"><span class="fu">==&gt;</span> <span class="fu">head</span> ((<span class="ch">&#39;H&#39;</span><span class="fu">:</span>__)<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>)</a>
+<a class="sourceLine" id="cb84-17" title="17"><span class="co">-- now the last ++ can operate</span></a>
+<a class="sourceLine" id="cb84-18" title="18"><span class="fu">==&gt;</span> <span class="fu">head</span> (<span class="ch">&#39;H&#39;</span><span class="fu">:</span>(__<span class="fu">++</span><span class="st">&quot;ipsum&quot;</span>))</a>
+<a class="sourceLine" id="cb84-19" title="19"><span class="fu">==&gt;</span> <span class="ch">&#39;H&#39;</span></a></code></pre></div>
 <p>So why use <code>foldl</code> at all? Let’s return to our first fold example again. Now, since <code>+</code> is a strict operation, both types of fold need to build up an expression with lots of <code>+</code>s. The Haskell implementation needs to track this expression in memory, which is why a problem like this is called a <em>space leak</em>.</p>
-<div class="sourceCode" id="cb85"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb85-1" data-line-number="1">    foldr (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb85-2" data-line-number="2"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> foldr (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb85-3" data-line-number="3"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> foldr (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb85-4" data-line-number="4"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> foldr (<span class="fu">+</span>) <span class="dv">0</span> []))</a>
-<a class="sourceLine" id="cb85-5" data-line-number="5"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>))</a>
-<a class="sourceLine" id="cb85-6" data-line-number="6"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb85-7" data-line-number="7"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">5</span></a>
-<a class="sourceLine" id="cb85-8" data-line-number="8"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
-<div class="sourceCode" id="cb86"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb86-1" data-line-number="1">    foldl (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb86-2" data-line-number="2"><span class="fu">==&gt;</span> foldl (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb86-3" data-line-number="3"><span class="fu">==&gt;</span> foldl (<span class="fu">+</span>) ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb86-4" data-line-number="4"><span class="fu">==&gt;</span> foldl (<span class="fu">+</span>) (((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span>) []</a>
-<a class="sourceLine" id="cb86-5" data-line-number="5"><span class="fu">==&gt;</span> ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a>
-<a class="sourceLine" id="cb86-6" data-line-number="6"><span class="fu">==&gt;</span> (  <span class="dv">1</span>  <span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a>
-<a class="sourceLine" id="cb86-7" data-line-number="7"><span class="fu">==&gt;</span>       <span class="dv">3</span>  <span class="fu">+</span><span class="dv">3</span></a>
-<a class="sourceLine" id="cb86-8" data-line-number="8"><span class="fu">==&gt;</span>          <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb85"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb85-1" title="1">    <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb85-2" title="2"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb85-3" title="3"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb85-4" title="4"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> <span class="fu">foldr</span> (<span class="fu">+</span>) <span class="dv">0</span> []))</a>
+<a class="sourceLine" id="cb85-5" title="5"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> (<span class="dv">3</span> <span class="fu">+</span> <span class="dv">0</span>))</a>
+<a class="sourceLine" id="cb85-6" title="6"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> (<span class="dv">2</span> <span class="fu">+</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb85-7" title="7"><span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">+</span> <span class="dv">5</span></a>
+<a class="sourceLine" id="cb85-8" title="8"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb86"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb86-1" title="1">    <span class="fu">foldl</span> (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb86-2" title="2"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb86-3" title="3"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">+</span>) ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb86-4" title="4"><span class="fu">==&gt;</span> <span class="fu">foldl</span> (<span class="fu">+</span>) (((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span>) []</a>
+<a class="sourceLine" id="cb86-5" title="5"><span class="fu">==&gt;</span> ((<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>)<span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a>
+<a class="sourceLine" id="cb86-6" title="6"><span class="fu">==&gt;</span> (  <span class="dv">1</span>  <span class="fu">+</span><span class="dv">2</span>)<span class="fu">+</span><span class="dv">3</span></a>
+<a class="sourceLine" id="cb86-7" title="7"><span class="fu">==&gt;</span>       <span class="dv">3</span>  <span class="fu">+</span><span class="dv">3</span></a>
+<a class="sourceLine" id="cb86-8" title="8"><span class="fu">==&gt;</span>          <span class="dv">6</span></a></code></pre></div>
 <p>Now let’s instead look at what happens when we use <code>foldl'</code>, a version of <code>foldl</code> that forces its second argument!</p>
-<div class="sourceCode" id="cb87"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb87-1" data-line-number="1">    foldl&#39; (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb87-2" data-line-number="2"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb87-3" data-line-number="3"><span class="co">-- force second argument</span></a>
-<a class="sourceLine" id="cb87-4" data-line-number="4"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb87-5" data-line-number="5"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb87-6" data-line-number="6"><span class="co">-- force second argument</span></a>
-<a class="sourceLine" id="cb87-7" data-line-number="7"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">3</span> [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb87-8" data-line-number="8"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) []</a>
-<a class="sourceLine" id="cb87-9" data-line-number="9"><span class="co">-- force second argument</span></a>
-<a class="sourceLine" id="cb87-10" data-line-number="10"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">6</span> []</a>
-<a class="sourceLine" id="cb87-11" data-line-number="11"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb87"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb87-1" title="1">    foldl&#39; (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb87-2" title="2"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb87-3" title="3"><span class="co">-- force second argument</span></a>
+<a class="sourceLine" id="cb87-4" title="4"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb87-5" title="5"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb87-6" title="6"><span class="co">-- force second argument</span></a>
+<a class="sourceLine" id="cb87-7" title="7"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">3</span> [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb87-8" title="8"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) []</a>
+<a class="sourceLine" id="cb87-9" title="9"><span class="co">-- force second argument</span></a>
+<a class="sourceLine" id="cb87-10" title="10"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">6</span> []</a>
+<a class="sourceLine" id="cb87-11" title="11"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
 <p>Now the work is performed incrementally while scanning the list. No space leak! Sometimes too much laziness can cause space leaks, and a bit of strictness can fix them.</p>
 <p>You can find <code>foldl'</code> in the <code>Data.List</code> module, and it works just like this. But how could one implement <code>foldl'</code>? We certainly know by now how to do it for a specific type, say <code>Int</code>. We just add a pattern match on the second argument that doesn’t change the semantics of the function.</p>
-<div class="sourceCode" id="cb88"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb88-1" data-line-number="1"><span class="ot">foldl&#39;Int ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb88-2" data-line-number="2">foldl&#39;Int f z [] <span class="fu">=</span> z</a>
-<a class="sourceLine" id="cb88-3" data-line-number="3">foldl&#39;Int f <span class="dv">0</span> (x<span class="fu">:</span>xs) <span class="fu">=</span> foldl&#39;Int f (f <span class="dv">0</span> x) xs</a>
-<a class="sourceLine" id="cb88-4" data-line-number="4">foldl&#39;Int f z (x<span class="fu">:</span>xs) <span class="fu">=</span> foldl&#39;Int f (f z x) xs</a></code></pre></div>
-<div class="sourceCode" id="cb89"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb89-1" data-line-number="1">    foldl&#39;Int (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb89-2" data-line-number="2"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb89-3" data-line-number="3"><span class="co">-- to be able to pick between the second and third equations, (0+1) is forced</span></a>
-<a class="sourceLine" id="cb89-4" data-line-number="4"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb89-5" data-line-number="5"><span class="co">-- the third equation applies</span></a>
-<a class="sourceLine" id="cb89-6" data-line-number="6"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb89-7" data-line-number="7"><span class="co">-- again, we need to pick between the second and third equations</span></a>
-<a class="sourceLine" id="cb89-8" data-line-number="8"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) <span class="dv">3</span> [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb89-9" data-line-number="9"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) []</a>
-<a class="sourceLine" id="cb89-10" data-line-number="10"><span class="fu">==&gt;</span> <span class="dv">3</span><span class="fu">+</span><span class="dv">3</span></a>
-<a class="sourceLine" id="cb89-11" data-line-number="11"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb88"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb88-1" title="1"><span class="ot">foldl&#39;Int ::</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span>) <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb88-2" title="2">foldl&#39;Int f z [] <span class="fu">=</span> z</a>
+<a class="sourceLine" id="cb88-3" title="3">foldl&#39;Int f <span class="dv">0</span> (x<span class="fu">:</span>xs) <span class="fu">=</span> foldl&#39;Int f (f <span class="dv">0</span> x) xs</a>
+<a class="sourceLine" id="cb88-4" title="4">foldl&#39;Int f z (x<span class="fu">:</span>xs) <span class="fu">=</span> foldl&#39;Int f (f z x) xs</a></code></pre></div>
+<div class="sourceCode" id="cb89"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb89-1" title="1">    foldl&#39;Int (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb89-2" title="2"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb89-3" title="3"><span class="co">-- to be able to pick between the second and third equations, (0+1) is forced</span></a>
+<a class="sourceLine" id="cb89-4" title="4"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb89-5" title="5"><span class="co">-- the third equation applies</span></a>
+<a class="sourceLine" id="cb89-6" title="6"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb89-7" title="7"><span class="co">-- again, we need to pick between the second and third equations</span></a>
+<a class="sourceLine" id="cb89-8" title="8"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) <span class="dv">3</span> [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb89-9" title="9"><span class="fu">==&gt;</span> foldl&#39;Int (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) []</a>
+<a class="sourceLine" id="cb89-10" title="10"><span class="fu">==&gt;</span> <span class="dv">3</span><span class="fu">+</span><span class="dv">3</span></a>
+<a class="sourceLine" id="cb89-11" title="11"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
 <p>To write a generic implementation of <code>foldl'</code> we need to introduce a new built-in function, <code>seq</code>. The call <code>seq a b</code> evaluates to <code>b</code> but forces <code>a</code> into WHNF. Here are some examples of using <code>seq</code> in GHCi. To demonstrate what gets evaluated, we use the special value <code>undefined</code>, which causes an error if something tries to evaluate it into WHNF.</p>
-<div class="sourceCode" id="cb90"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb90-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> seq (not <span class="dt">True</span>) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb90-2" data-line-number="2"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb90-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> seq undefined <span class="dv">3</span></a>
-<a class="sourceLine" id="cb90-4" data-line-number="4"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
-<a class="sourceLine" id="cb90-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> (seq (not <span class="dt">True</span>) <span class="dv">3</span>) <span class="fu">+</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb90-6" data-line-number="6"><span class="dv">10</span></a>
-<a class="sourceLine" id="cb90-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (seq undefined <span class="dv">3</span>) <span class="fu">+</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb90-8" data-line-number="8"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
-<a class="sourceLine" id="cb90-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f x <span class="fu">=</span> f x <span class="kw">in</span> seq (f <span class="dv">3</span>) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb90-10" data-line-number="10"><span class="co">-- ...infinite recursion</span></a></code></pre></div>
+<div class="sourceCode" id="cb90"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb90-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">seq</span> (<span class="fu">not</span> <span class="dt">True</span>) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb90-2" title="2"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb90-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">seq</span> <span class="fu">undefined</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb90-4" title="4"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
+<a class="sourceLine" id="cb90-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> (<span class="fu">seq</span> (<span class="fu">not</span> <span class="dt">True</span>) <span class="dv">3</span>) <span class="fu">+</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb90-6" title="6"><span class="dv">10</span></a>
+<a class="sourceLine" id="cb90-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> (<span class="fu">seq</span> <span class="fu">undefined</span> <span class="dv">3</span>) <span class="fu">+</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb90-8" title="8"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
+<a class="sourceLine" id="cb90-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> f x <span class="fu">=</span> f x <span class="kw">in</span> <span class="fu">seq</span> (f <span class="dv">3</span>) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb90-10" title="10"><span class="co">-- ...infinite recursion</span></a></code></pre></div>
 <p>As an example of using <code>seq</code> in a function, here’s a version of <code>head</code> that doesn’t work for infinite lists (since it evaluates the last element of the list):</p>
-<div class="sourceCode" id="cb91"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb91-1" data-line-number="1"><span class="ot">strictHead ::</span> [a] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb91-2" data-line-number="2">strictHead xs <span class="fu">=</span> seq (last xs) (head xs)</a></code></pre></div>
+<div class="sourceCode" id="cb91"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb91-1" title="1"><span class="ot">strictHead ::</span> [a] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb91-2" title="2">strictHead xs <span class="fu">=</span> <span class="fu">seq</span> (<span class="fu">last</span> xs) (<span class="fu">head</span> xs)</a></code></pre></div>
 <p>Let’s play around with it in GHCi:</p>
-<div class="sourceCode" id="cb92"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb92-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> head [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb92-2" data-line-number="2"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb92-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb92-4" data-line-number="4"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb92-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> head (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>undefined)</a>
-<a class="sourceLine" id="cb92-6" data-line-number="6"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb92-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>undefined)</a>
-<a class="sourceLine" id="cb92-8" data-line-number="8"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
-<a class="sourceLine" id="cb92-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> head [<span class="dv">1</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb92-10" data-line-number="10"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb92-11" data-line-number="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead [<span class="dv">1</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb92-12" data-line-number="12"><span class="co">-- ...infinite recursion</span></a></code></pre></div>
+<div class="sourceCode" id="cb92"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb92-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb92-2" title="2"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb92-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb92-4" title="4"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb92-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:undefined</span>)</a>
+<a class="sourceLine" id="cb92-6" title="6"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb92-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:undefined</span>)</a>
+<a class="sourceLine" id="cb92-8" title="8"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a>
+<a class="sourceLine" id="cb92-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">head</span> [<span class="dv">1</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb92-10" title="10"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb92-11" title="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> strictHead [<span class="dv">1</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb92-12" title="12"><span class="co">-- ...infinite recursion</span></a></code></pre></div>
 <p>Finally, here’s a definition for <code>foldl'</code>. Note how we need to introduce sharing of a new variable, <code>z'</code>, to be able to make <code>seq</code> evaluate the new value and then use it in a recursive call. The new definition is also used in a more detailed evaluation of <code>foldl' (+) 0 [1,2,3]</code> below.</p>
-<div class="sourceCode" id="cb93"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb93-1" data-line-number="1"><span class="ot">foldl&#39; ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb93-2" data-line-number="2">foldl&#39; f z [] <span class="fu">=</span> z</a>
-<a class="sourceLine" id="cb93-3" data-line-number="3">foldl&#39; f z (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">let</span> z&#39; <span class="fu">=</span> f z x</a>
-<a class="sourceLine" id="cb93-4" data-line-number="4">                    <span class="kw">in</span> seq z&#39; (foldl f z&#39; xs)</a></code></pre></div>
-<div class="sourceCode" id="cb94"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb94-1" data-line-number="1">    foldl&#39; (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb94-2" data-line-number="2"><span class="fu">==&gt;</span> seq (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="co">-- seq forces first argument</span></a>
-<a class="sourceLine" id="cb94-3" data-line-number="3">          <span class="fu">|</span>                 <span class="fu">|</span></a>
-<a class="sourceLine" id="cb94-4" data-line-number="4">          <span class="fu">+-----</span>sharing<span class="co">-----&#39;</span></a>
-<a class="sourceLine" id="cb94-5" data-line-number="5">          <span class="fu">|</span>                 <span class="fu">|</span></a>
-<a class="sourceLine" id="cb94-6" data-line-number="6"><span class="fu">==&gt;</span> seq   <span class="dv">1</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">1</span>   [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="co">-- first argument to seq in WHNF, seq disappears</span></a>
-<a class="sourceLine" id="cb94-7" data-line-number="7"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb94-8" data-line-number="8"><span class="fu">==&gt;</span> seq (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb94-9" data-line-number="9"><span class="fu">==&gt;</span> seq   <span class="dv">3</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">3</span>   [<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb94-10" data-line-number="10"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>)   <span class="dv">3</span>   [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb94-11" data-line-number="11"><span class="fu">==&gt;</span> seq (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) [])</a>
-<a class="sourceLine" id="cb94-12" data-line-number="12"><span class="fu">==&gt;</span> seq   <span class="dv">6</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">6</span>   [])</a>
-<a class="sourceLine" id="cb94-13" data-line-number="13"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>)   <span class="dv">6</span>   []</a>
-<a class="sourceLine" id="cb94-14" data-line-number="14"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb93"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb93-1" title="1"><span class="ot">foldl&#39; ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> [b] <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb93-2" title="2">foldl&#39; f z [] <span class="fu">=</span> z</a>
+<a class="sourceLine" id="cb93-3" title="3">foldl&#39; f z (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">let</span> z&#39; <span class="fu">=</span> f z x</a>
+<a class="sourceLine" id="cb93-4" title="4">                    <span class="kw">in</span> <span class="fu">seq</span> z&#39; (<span class="fu">foldl</span> f z&#39; xs)</a></code></pre></div>
+<div class="sourceCode" id="cb94"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb94-1" title="1">    foldl&#39; (<span class="fu">+</span>) <span class="dv">0</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb94-2" title="2"><span class="fu">==&gt;</span> <span class="fu">seq</span> (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">0</span><span class="fu">+</span><span class="dv">1</span>) [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="co">-- seq forces first argument</span></a>
+<a class="sourceLine" id="cb94-3" title="3">          <span class="fu">|</span>                 <span class="fu">|</span></a>
+<a class="sourceLine" id="cb94-4" title="4">          <span class="fu">+-----</span>sharing<span class="co">-----&#39;</span></a>
+<a class="sourceLine" id="cb94-5" title="5">          <span class="fu">|</span>                 <span class="fu">|</span></a>
+<a class="sourceLine" id="cb94-6" title="6"><span class="fu">==&gt;</span> <span class="fu">seq</span>   <span class="dv">1</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">1</span>   [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="co">-- first argument to seq in WHNF, seq disappears</span></a>
+<a class="sourceLine" id="cb94-7" title="7"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>) <span class="dv">1</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb94-8" title="8"><span class="fu">==&gt;</span> <span class="fu">seq</span> (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">1</span><span class="fu">+</span><span class="dv">2</span>) [<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb94-9" title="9"><span class="fu">==&gt;</span> <span class="fu">seq</span>   <span class="dv">3</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">3</span>   [<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb94-10" title="10"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>)   <span class="dv">3</span>   [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb94-11" title="11"><span class="fu">==&gt;</span> <span class="fu">seq</span> (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) (foldl&#39; (<span class="fu">+</span>) (<span class="dv">3</span><span class="fu">+</span><span class="dv">3</span>) [])</a>
+<a class="sourceLine" id="cb94-12" title="12"><span class="fu">==&gt;</span> <span class="fu">seq</span>   <span class="dv">6</span>   (foldl&#39; (<span class="fu">+</span>)   <span class="dv">6</span>   [])</a>
+<a class="sourceLine" id="cb94-13" title="13"><span class="fu">==&gt;</span> foldl&#39; (<span class="fu">+</span>)   <span class="dv">6</span>   []</a>
+<a class="sourceLine" id="cb94-14" title="14"><span class="fu">==&gt;</span> <span class="dv">6</span></a></code></pre></div>
 <p>We won’t dive deeper into this subject on this course, but it’s important that you’re aware that <code>seq</code> exists. You can find more about <code>seq</code> on <a href="https://wiki.haskell.org/Seq">the Haskell Wiki</a> and learn more about when it is necessary to add strictness in <a href="https://book.realworldhaskell.org/read/profiling-and-optimization.html">Real World Haskell</a>. Often it’s nicer to use <em>bang patterns</em> instead of <code>seq</code>, as discussed by <a href="https://www.fpcomplete.com/blog/2017/09/all-about-strictness/">FPComplete</a> and <a href="http://book.realworldhaskell.org/read/profiling-and-optimization.html">Real World Haskell</a>.</p>
 <h2 id="newtype-declarations"><span class="header-section-number">10.7</span> Newtype Declarations</h2>
 <p>Recall lecture 7. Sometimes we need boxed types. There’s a special keyword <code>newtype</code> that can be used instead of <code>data</code> when a boxed type is needed. <code>newtype</code> expects exactly one constructor, with exactly one field. For instance,</p>
-<div class="sourceCode" id="cb95"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb95-1" data-line-number="1"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb95"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb95-1" title="1"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a></code></pre></div>
 <p>However, the following won’t work, you need <code>data</code>:</p>
-<div class="sourceCode" id="cb96"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb96-1" data-line-number="1"><span class="co">-- the compiler won&#39;t accept these!</span></a>
-<a class="sourceLine" id="cb96-2" data-line-number="2"><span class="kw">newtype</span> <span class="dt">Currency</span> <span class="fu">=</span> <span class="dt">Dollars</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Euros</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb96-3" data-line-number="3"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb96"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb96-1" title="1"><span class="co">-- the compiler won&#39;t accept these!</span></a>
+<a class="sourceLine" id="cb96-2" title="2"><span class="kw">newtype</span> <span class="dt">Currency</span> <span class="fu">=</span> <span class="dt">Dollars</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">Euros</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb96-3" title="3"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span> <span class="dt">Int</span></a></code></pre></div>
 <p>So what’s the difference? In terms of writing code, nothing. You work with a <code>newtype</code> exactly as you would with a <code>data</code>. However, the memory layout is different. Using <code>data</code> introduces an indirection layer (the constructor), but using <code>newtype</code> doesn’t. The indirection for <code>data</code> is necessary to support multiple constructors and multiple fields. An illustration:</p>
-<div class="sourceCode" id="cb97"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb97-1" data-line-number="1">code<span class="fu">:</span>                                 memory<span class="fu">:</span></a>
-<a class="sourceLine" id="cb97-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb97-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span>                x <span class="fu">--&gt;</span> <span class="dt">Cents</span> <span class="fu">--&gt;</span> <span class="dv">100</span></a>
-<a class="sourceLine" id="cb97-4" data-line-number="4">x <span class="fu">=</span> <span class="dt">Cents</span> <span class="dv">100</span></a>
-<a class="sourceLine" id="cb97-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb97-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb97-7" data-line-number="7"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span>             x <span class="fu">--&gt;</span> <span class="dv">100</span></a>
-<a class="sourceLine" id="cb97-8" data-line-number="8">x <span class="fu">=</span> <span class="dt">Cents</span> <span class="dv">100</span></a></code></pre></div>
+<div class="sourceCode" id="cb97"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb97-1" title="1">code<span class="fu">:</span>                                 memory<span class="fu">:</span></a>
+<a class="sourceLine" id="cb97-2" title="2"></a>
+<a class="sourceLine" id="cb97-3" title="3"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span>                x <span class="fu">--&gt;</span> <span class="dt">Cents</span> <span class="fu">--&gt;</span> <span class="dv">100</span></a>
+<a class="sourceLine" id="cb97-4" title="4">x <span class="fu">=</span> <span class="dt">Cents</span> <span class="dv">100</span></a>
+<a class="sourceLine" id="cb97-5" title="5"></a>
+<a class="sourceLine" id="cb97-6" title="6"></a>
+<a class="sourceLine" id="cb97-7" title="7"><span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span>             x <span class="fu">--&gt;</span> <span class="dv">100</span></a>
+<a class="sourceLine" id="cb97-8" title="8">x <span class="fu">=</span> <span class="dt">Cents</span> <span class="dv">100</span></a></code></pre></div>
 <p>This difference has many repercussions. First of all, <code>newtype</code> is more efficient: the type can be said to “disappear” when compiling. The type is still checked though, so you get type safety without any performance impact. Secondly, newtypes are <em>strict</em>. Concretely, this means that <code>Money x</code> is in weak head normal form only if <code>x</code> is in WHNF. This can be witnessed in GHCi:</p>
-<div class="sourceCode" id="cb98"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb98-1" data-line-number="1"><span class="co">-- if we use data, Cents undefined is in WHNF</span></a>
-<a class="sourceLine" id="cb98-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb98-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> seq (<span class="dt">Cents</span> undefined) <span class="dt">True</span></a>
-<a class="sourceLine" id="cb98-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb98-5" data-line-number="5"><span class="co">-- if we use newtype, Cents undefined isn&#39;t in WHNF, and trying</span></a>
-<a class="sourceLine" id="cb98-6" data-line-number="6"><span class="co">-- to make it so trips up in undefined</span></a>
-<a class="sourceLine" id="cb98-7" data-line-number="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb98-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> seq (<span class="dt">Cents</span> undefined) <span class="dt">True</span></a>
-<a class="sourceLine" id="cb98-9" data-line-number="9"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a></code></pre></div>
+<div class="sourceCode" id="cb98"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb98-1" title="1"><span class="co">-- if we use data, Cents undefined is in WHNF</span></a>
+<a class="sourceLine" id="cb98-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb98-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">seq</span> (<span class="dt">Cents</span> <span class="fu">undefined</span>) <span class="dt">True</span></a>
+<a class="sourceLine" id="cb98-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb98-5" title="5"><span class="co">-- if we use newtype, Cents undefined isn&#39;t in WHNF, and trying</span></a>
+<a class="sourceLine" id="cb98-6" title="6"><span class="co">-- to make it so trips up in undefined</span></a>
+<a class="sourceLine" id="cb98-7" title="7"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">newtype</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Cents</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb98-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">seq</span> (<span class="dt">Cents</span> <span class="fu">undefined</span>) <span class="dt">True</span></a>
+<a class="sourceLine" id="cb98-9" title="9"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> Prelude.undefined</a></code></pre></div>
 <p>So when should you use <code>newtype</code>? In general it’s best to use <code>newtype</code> whenever you have a single-field single-constructor datatype. However nothing will go catastrophically wrong if you always use <code>data</code>. The <code>newtype</code> pattern is also often used when you need to define a different type class instance for a type. Here’s an example that defines a number type with an inverted ordering</p>
-<div class="sourceCode" id="cb99"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb99-1" data-line-number="1"><span class="kw">newtype</span> <span class="dt">Inverted</span> <span class="fu">=</span> <span class="dt">Inverted</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb99-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb99-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb99-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">Inverted</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb99-5" data-line-number="5">  compare (<span class="dt">Inverted</span> i) (<span class="dt">Inverted</span> j) <span class="fu">=</span> compare j i</a></code></pre></div>
-<div class="sourceCode" id="cb100"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb100-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb100-2" data-line-number="2">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb100-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> sort [<span class="dt">Inverted</span> <span class="dv">1</span>,<span class="dt">Inverted</span> <span class="dv">2</span>,<span class="dt">Inverted</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb100-4" data-line-number="4">[<span class="dt">Inverted</span> <span class="dv">3</span>,<span class="dt">Inverted</span> <span class="dv">2</span>,<span class="dt">Inverted</span> <span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb99"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb99-1" title="1"><span class="kw">newtype</span> <span class="dt">Inverted</span> <span class="fu">=</span> <span class="dt">Inverted</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb99-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb99-3" title="3"></a>
+<a class="sourceLine" id="cb99-4" title="4"><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">Inverted</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb99-5" title="5">  <span class="fu">compare</span> (<span class="dt">Inverted</span> i) (<span class="dt">Inverted</span> j) <span class="fu">=</span> <span class="fu">compare</span> j i</a></code></pre></div>
+<div class="sourceCode" id="cb100"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb100-1" title="1"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb100-2" title="2">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb100-3" title="3"><span class="dt">Prelude</span> <span class="dt">Data.List</span><span class="fu">&gt;</span> <span class="fu">sort</span> [<span class="dt">Inverted</span> <span class="dv">1</span>,<span class="dt">Inverted</span> <span class="dv">2</span>,<span class="dt">Inverted</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb100-4" title="4">[<span class="dt">Inverted</span> <span class="dv">3</span>,<span class="dt">Inverted</span> <span class="dv">2</span>,<span class="dt">Inverted</span> <span class="dv">1</span>]</a></code></pre></div>
 <h2 id="something-fun-tying-the-knot"><span class="header-section-number">10.8</span> Something Fun: Tying the Knot</h2>
 <!-- TODO: Should we discuss recursion and corecursion? Like
 generating and consuming lists or streams. -->
 <p>Now that we know about sharing and path copying, we can make our own <em>cyclic datastructures</em>. Remember the <code>cycle</code> examples from the list lecture?</p>
-<div class="sourceCode" id="cb101"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb101-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> take <span class="dv">21</span> <span class="fu">$</span> cycle <span class="st">&quot;asdf&quot;</span></a>
-<a class="sourceLine" id="cb101-2" data-line-number="2"><span class="st">&quot;asdfasdfasdfasdfasdfa&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb101"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb101-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">take</span> <span class="dv">21</span> <span class="fu">$</span> <span class="fu">cycle</span> <span class="st">&quot;asdf&quot;</span></a>
+<a class="sourceLine" id="cb101-2" title="2"><span class="st">&quot;asdfasdfasdfasdfasdfa&quot;</span></a></code></pre></div>
 <p>This is what it looks like in memory:</p>
 <p><img src="img/DAG4.svg" /></p>
 <p>Earlier it was said that Haskell data forms directed graphs in memory. This is an example of a directed graph with a cycle.</p>
 <p>How can we define structures like this? We just give a value a name, and refer to that name in the value itself. That is, the value is <em>recursive</em> or <em>self-referential</em>. This trick is known as <em>tying the knot</em>. A simple example:</p>
-<div class="sourceCode" id="cb102"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb102-1" data-line-number="1">  code                     memory</a>
-<a class="sourceLine" id="cb102-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb102-3" data-line-number="3"><span class="kw">let</span> xs <span class="fu">=</span> <span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>xs      xs <span class="ot">-&gt;</span> (<span class="dv">1</span><span class="fu">:</span>) <span class="ot">-&gt;</span> (<span class="dv">2</span><span class="fu">:</span>) <span class="fu">-+</span></a>
-<a class="sourceLine" id="cb102-4" data-line-number="4"> <span class="kw">in</span> xs                      <span class="fu">^</span>            <span class="fu">|</span></a>
-<a class="sourceLine" id="cb102-5" data-line-number="5">                            <span class="fu">+------------+</span></a></code></pre></div>
+<div class="sourceCode" id="cb102"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb102-1" title="1">  code                     memory</a>
+<a class="sourceLine" id="cb102-2" title="2"></a>
+<a class="sourceLine" id="cb102-3" title="3"><span class="kw">let</span> xs <span class="fu">=</span> <span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>xs      xs <span class="ot">-&gt;</span> (<span class="dv">1</span><span class="fu">:</span>) <span class="ot">-&gt;</span> (<span class="dv">2</span><span class="fu">:</span>) <span class="fu">-+</span></a>
+<a class="sourceLine" id="cb102-4" title="4"> <span class="kw">in</span> xs                      <span class="fu">^</span>            <span class="fu">|</span></a>
+<a class="sourceLine" id="cb102-5" title="5">                            <span class="fu">+------------+</span></a></code></pre></div>
 <p>Note how we use the name <code>xs</code> inside the definition of <code>xs</code>. When we make a recursive definition like this, sharing causes it to turn into a cyclic structure in memory.</p>
 <p>A more fun example: a simple adventure game where the world is a self-referential structure. Note how the cyclic structure is built with local definitions that refer to each other.</p>
-<div class="sourceCode" id="cb103"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb103-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Room</span> <span class="fu">=</span> <span class="dt">Room</span> <span class="dt">String</span> [(<span class="dt">String</span>,<span class="dt">Room</span>)]</a>
-<a class="sourceLine" id="cb103-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb103-3" data-line-number="3"><span class="ot">describe ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb103-4" data-line-number="4">describe (<span class="dt">Room</span> s _) <span class="fu">=</span> s</a>
-<a class="sourceLine" id="cb103-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb103-6" data-line-number="6"><span class="ot">move ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Room</span></a>
-<a class="sourceLine" id="cb103-7" data-line-number="7">move (<span class="dt">Room</span> _ directions) direction <span class="fu">=</span> lookup direction directions</a>
-<a class="sourceLine" id="cb103-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb103-9" data-line-number="9"><span class="ot">world ::</span> <span class="dt">Room</span></a>
-<a class="sourceLine" id="cb103-10" data-line-number="10">world <span class="fu">=</span> meadow</a>
-<a class="sourceLine" id="cb103-11" data-line-number="11">  <span class="kw">where</span></a>
-<a class="sourceLine" id="cb103-12" data-line-number="12">    meadow <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span> [(<span class="st">&quot;Stay&quot;</span>,meadow),(<span class="st">&quot;Enter cave&quot;</span>,cave)]</a>
-<a class="sourceLine" id="cb103-13" data-line-number="13">    cave <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;You are in a cave&quot;</span> [(<span class="st">&quot;Exit&quot;</span>,meadow),(<span class="st">&quot;Go deeper&quot;</span>,tunnel)]</a>
-<a class="sourceLine" id="cb103-14" data-line-number="14">    tunnel <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span></a>
-<a class="sourceLine" id="cb103-15" data-line-number="15">                  [(<span class="st">&quot;Go back&quot;</span>,cave),(<span class="st">&quot;Go left&quot;</span>,pit),(<span class="st">&quot;Go right&quot;</span>,treasure)]</a>
-<a class="sourceLine" id="cb103-16" data-line-number="16">    pit <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;You fall into a pit. There is no way out.&quot;</span> []</a>
-<a class="sourceLine" id="cb103-17" data-line-number="17">    treasure <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;A green light from a terminal fills the room. The terminal says &lt;&lt;loop&gt;&gt;.&quot;</span></a>
-<a class="sourceLine" id="cb103-18" data-line-number="18">                    [(<span class="st">&quot;Go back&quot;</span>,tunnel)]</a>
-<a class="sourceLine" id="cb103-19" data-line-number="19"></a>
-<a class="sourceLine" id="cb103-20" data-line-number="20"><span class="ot">play ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb103-21" data-line-number="21">play room [] <span class="fu">=</span> [describe room]</a>
-<a class="sourceLine" id="cb103-22" data-line-number="22">play room (d<span class="fu">:</span>ds) <span class="fu">=</span> <span class="kw">case</span> move room d <span class="kw">of</span> <span class="dt">Nothing</span> <span class="ot">-&gt;</span> [describe room]</a>
-<a class="sourceLine" id="cb103-23" data-line-number="23">                                       <span class="dt">Just</span> r <span class="ot">-&gt;</span> describe room <span class="fu">:</span> play r ds</a></code></pre></div>
-<div class="sourceCode" id="cb104"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb104-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> play world [<span class="st">&quot;Stay&quot;</span>,<span class="st">&quot;Enter cave&quot;</span>,<span class="st">&quot;Go deeper&quot;</span>,<span class="st">&quot;Go back&quot;</span>,<span class="st">&quot;Go deeper&quot;</span>,<span class="st">&quot;Go right&quot;</span>]</a>
-<a class="sourceLine" id="cb104-2" data-line-number="2">[<span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span>,</a>
-<a class="sourceLine" id="cb104-3" data-line-number="3"> <span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span>,</a>
-<a class="sourceLine" id="cb104-4" data-line-number="4"> <span class="st">&quot;You are in a cave&quot;</span>,</a>
-<a class="sourceLine" id="cb104-5" data-line-number="5"> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span>,</a>
-<a class="sourceLine" id="cb104-6" data-line-number="6"> <span class="st">&quot;You are in a cave&quot;</span>,</a>
-<a class="sourceLine" id="cb104-7" data-line-number="7"> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span>,</a>
-<a class="sourceLine" id="cb104-8" data-line-number="8"> <span class="st">&quot;A green light from a computer terminal floods the room. The terminal says &lt;&lt;loop&gt;&gt;.&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb103"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb103-1" title="1"><span class="kw">data</span> <span class="dt">Room</span> <span class="fu">=</span> <span class="dt">Room</span> <span class="dt">String</span> [(<span class="dt">String</span>,<span class="dt">Room</span>)]</a>
+<a class="sourceLine" id="cb103-2" title="2"></a>
+<a class="sourceLine" id="cb103-3" title="3"><span class="ot">describe ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb103-4" title="4">describe (<span class="dt">Room</span> s _) <span class="fu">=</span> s</a>
+<a class="sourceLine" id="cb103-5" title="5"></a>
+<a class="sourceLine" id="cb103-6" title="6"><span class="ot">move ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Room</span></a>
+<a class="sourceLine" id="cb103-7" title="7">move (<span class="dt">Room</span> _ directions) direction <span class="fu">=</span> <span class="fu">lookup</span> direction directions</a>
+<a class="sourceLine" id="cb103-8" title="8"></a>
+<a class="sourceLine" id="cb103-9" title="9"><span class="ot">world ::</span> <span class="dt">Room</span></a>
+<a class="sourceLine" id="cb103-10" title="10">world <span class="fu">=</span> meadow</a>
+<a class="sourceLine" id="cb103-11" title="11">  <span class="kw">where</span></a>
+<a class="sourceLine" id="cb103-12" title="12">    meadow <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span> [(<span class="st">&quot;Stay&quot;</span>,meadow),(<span class="st">&quot;Enter cave&quot;</span>,cave)]</a>
+<a class="sourceLine" id="cb103-13" title="13">    cave <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;You are in a cave&quot;</span> [(<span class="st">&quot;Exit&quot;</span>,meadow),(<span class="st">&quot;Go deeper&quot;</span>,tunnel)]</a>
+<a class="sourceLine" id="cb103-14" title="14">    tunnel <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span></a>
+<a class="sourceLine" id="cb103-15" title="15">                  [(<span class="st">&quot;Go back&quot;</span>,cave),(<span class="st">&quot;Go left&quot;</span>,pit),(<span class="st">&quot;Go right&quot;</span>,treasure)]</a>
+<a class="sourceLine" id="cb103-16" title="16">    pit <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;You fall into a pit. There is no way out.&quot;</span> []</a>
+<a class="sourceLine" id="cb103-17" title="17">    treasure <span class="fu">=</span> <span class="dt">Room</span> <span class="st">&quot;A green light from a terminal fills the room. The terminal says &lt;&lt;loop&gt;&gt;.&quot;</span></a>
+<a class="sourceLine" id="cb103-18" title="18">                    [(<span class="st">&quot;Go back&quot;</span>,tunnel)]</a>
+<a class="sourceLine" id="cb103-19" title="19"></a>
+<a class="sourceLine" id="cb103-20" title="20"><span class="ot">play ::</span> <span class="dt">Room</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb103-21" title="21">play room [] <span class="fu">=</span> [describe room]</a>
+<a class="sourceLine" id="cb103-22" title="22">play room (d<span class="fu">:</span>ds) <span class="fu">=</span> <span class="kw">case</span> move room d <span class="kw">of</span> <span class="dt">Nothing</span> <span class="ot">-&gt;</span> [describe room]</a>
+<a class="sourceLine" id="cb103-23" title="23">                                       <span class="dt">Just</span> r <span class="ot">-&gt;</span> describe room <span class="fu">:</span> play r ds</a></code></pre></div>
+<div class="sourceCode" id="cb104"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb104-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> play world [<span class="st">&quot;Stay&quot;</span>,<span class="st">&quot;Enter cave&quot;</span>,<span class="st">&quot;Go deeper&quot;</span>,<span class="st">&quot;Go back&quot;</span>,<span class="st">&quot;Go deeper&quot;</span>,<span class="st">&quot;Go right&quot;</span>]</a>
+<a class="sourceLine" id="cb104-2" title="2">[<span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span>,</a>
+<a class="sourceLine" id="cb104-3" title="3"> <span class="st">&quot;It&#39;s a flowery meadow next to a cliff.&quot;</span>,</a>
+<a class="sourceLine" id="cb104-4" title="4"> <span class="st">&quot;You are in a cave&quot;</span>,</a>
+<a class="sourceLine" id="cb104-5" title="5"> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span>,</a>
+<a class="sourceLine" id="cb104-6" title="6"> <span class="st">&quot;You are in a cave&quot;</span>,</a>
+<a class="sourceLine" id="cb104-7" title="7"> <span class="st">&quot;This is a very dark tunnel. It seems you can either go left or right.&quot;</span>,</a>
+<a class="sourceLine" id="cb104-8" title="8"> <span class="st">&quot;A green light from a computer terminal floods the room. The terminal says &lt;&lt;loop&gt;&gt;.&quot;</span>]</a></code></pre></div>
 <p>Here’s what the <code>world</code> of the game looks like in memory:</p>
 <pre><code>               ,-----------------,
                v                 |
@@ -1436,70 +1434,70 @@ pit-----&gt;|Room &quot;You fall...&quot; []|    treasure---&gt;|Room &quot;A gr
 <h2 id="something-fun-debug.trace"><span class="header-section-number">10.9</span> Something Fun: Debug.Trace</h2>
 <p>Even though Haskell is a pure programming language, we can sometimes gain insights by sprinkling in a bit of impurity.</p>
 <p>We can use the function <code>trace :: String -&gt; a -&gt; a</code> from the module <code>Debug.Trace</code> to peek into Haskell evaluation. The expression <code>trace &quot;message&quot; x</code> is the same as <code>x</code>, but prints <code>message</code> when it is evaluated (forced). We can use <code>trace</code> to witness the laziness of the <code>||</code> operator:</p>
-<div class="sourceCode" id="cb106"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb106-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Debug.Trace</span></a>
-<a class="sourceLine" id="cb106-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb106-3" data-line-number="3">a</a>
-<a class="sourceLine" id="cb106-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb106-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">False</span> <span class="fu">||</span> trace <span class="st">&quot;b&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb106-6" data-line-number="6">a</a>
-<a class="sourceLine" id="cb106-7" data-line-number="7">b</a>
-<a class="sourceLine" id="cb106-8" data-line-number="8"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb106-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">True</span> <span class="fu">||</span> trace <span class="st">&quot;b&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb106-10" data-line-number="10">a</a>
-<a class="sourceLine" id="cb106-11" data-line-number="11"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb106"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb106-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Debug.Trace</span></a>
+<a class="sourceLine" id="cb106-2" title="2"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb106-3" title="3">a</a>
+<a class="sourceLine" id="cb106-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb106-5" title="5"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">False</span> <span class="fu">||</span> trace <span class="st">&quot;b&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb106-6" title="6">a</a>
+<a class="sourceLine" id="cb106-7" title="7">b</a>
+<a class="sourceLine" id="cb106-8" title="8"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb106-9" title="9"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> trace <span class="st">&quot;a&quot;</span> <span class="dt">True</span> <span class="fu">||</span> trace <span class="st">&quot;b&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb106-10" title="10">a</a>
+<a class="sourceLine" id="cb106-11" title="11"><span class="dt">True</span></a></code></pre></div>
 <p>We can also have a look at when list elements are evaluated. Note how <code>length</code> doesn’t need to evaluate the elements of the list, and <code>sum</code> needs to evaluate all of them. (To be precise, <code>head xs</code> doesn’t actually evaluate the first element of <code>xs</code>, but returns it to GHCi, which evaluates it in order to show it.)</p>
-<div class="sourceCode" id="cb107"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb107-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> head [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb107-2" data-line-number="2">first</a>
-<a class="sourceLine" id="cb107-3" data-line-number="3"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb107-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> last [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb107-5" data-line-number="5">third</a>
-<a class="sourceLine" id="cb107-6" data-line-number="6"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb107-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> length [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb107-8" data-line-number="8"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb107-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> sum [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb107-10" data-line-number="10">third</a>
-<a class="sourceLine" id="cb107-11" data-line-number="11">second</a>
-<a class="sourceLine" id="cb107-12" data-line-number="12">first</a>
-<a class="sourceLine" id="cb107-13" data-line-number="13"><span class="dv">6</span></a></code></pre></div>
+<div class="sourceCode" id="cb107"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb107-1" title="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="fu">head</span> [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb107-2" title="2">first</a>
+<a class="sourceLine" id="cb107-3" title="3"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb107-4" title="4"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="fu">last</span> [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb107-5" title="5">third</a>
+<a class="sourceLine" id="cb107-6" title="6"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb107-7" title="7"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="fu">length</span> [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb107-8" title="8"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb107-9" title="9"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="fu">sum</span> [trace <span class="st">&quot;first&quot;</span> <span class="dv">1</span>, trace <span class="st">&quot;second&quot;</span> <span class="dv">2</span>, trace <span class="st">&quot;third&quot;</span> <span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb107-10" title="10">third</a>
+<a class="sourceLine" id="cb107-11" title="11">second</a>
+<a class="sourceLine" id="cb107-12" title="12">first</a>
+<a class="sourceLine" id="cb107-13" title="13"><span class="dv">6</span></a></code></pre></div>
 <p><code>Debug.Trace</code> also offers useful variants of <code>trace</code>. A notable one is <code>traceShowId x</code> which prints <code>show x</code> and evaluates to <code>x</code>. Let’s verify the evaluation of our previous head-filter-map example using <code>traceShowId</code>. Note how even though we map <code>traceShowId</code> over the infinite list <code>[0..]</code>, only 6 values are actually evaluated. The last 243 is the returned value, not a trace print.</p>
-<div class="sourceCode" id="cb108"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb108-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> head (filter (<span class="fu">&gt;</span><span class="dv">100</span>) (map (\x <span class="ot">-&gt;</span> traceShowId (<span class="dv">3</span><span class="fu">^</span>x)) [<span class="dv">0</span><span class="fu">..</span>]))</a>
-<a class="sourceLine" id="cb108-2" data-line-number="2"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb108-3" data-line-number="3"><span class="dv">3</span></a>
-<a class="sourceLine" id="cb108-4" data-line-number="4"><span class="dv">9</span></a>
-<a class="sourceLine" id="cb108-5" data-line-number="5"><span class="dv">27</span></a>
-<a class="sourceLine" id="cb108-6" data-line-number="6"><span class="dv">81</span></a>
-<a class="sourceLine" id="cb108-7" data-line-number="7"><span class="dv">243</span></a>
-<a class="sourceLine" id="cb108-8" data-line-number="8"><span class="dv">243</span></a></code></pre></div>
+<div class="sourceCode" id="cb108"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb108-1" title="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="fu">head</span> (<span class="fu">filter</span> (<span class="fu">&gt;</span><span class="dv">100</span>) (<span class="fu">map</span> (\x <span class="ot">-&gt;</span> traceShowId (<span class="dv">3</span><span class="fu">^</span>x)) [<span class="dv">0</span><span class="fu">..</span>]))</a>
+<a class="sourceLine" id="cb108-2" title="2"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb108-3" title="3"><span class="dv">3</span></a>
+<a class="sourceLine" id="cb108-4" title="4"><span class="dv">9</span></a>
+<a class="sourceLine" id="cb108-5" title="5"><span class="dv">27</span></a>
+<a class="sourceLine" id="cb108-6" title="6"><span class="dv">81</span></a>
+<a class="sourceLine" id="cb108-7" title="7"><span class="dv">243</span></a>
+<a class="sourceLine" id="cb108-8" title="8"><span class="dv">243</span></a></code></pre></div>
 <p><code>Debug.Trace</code> is especially useful when you have an infinite recursion bug. Here’s an example:</p>
-<div class="sourceCode" id="cb109"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb109-1" data-line-number="1"><span class="co">-- computes sums like 7+5+3+1</span></a>
-<a class="sourceLine" id="cb109-2" data-line-number="2"><span class="ot">sumEverySecond ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb109-3" data-line-number="3">sumEverySecond <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb109-4" data-line-number="4">sumEverySecond n <span class="fu">=</span> n <span class="fu">+</span> sumEverySecond (n<span class="fu">-</span><span class="dv">2</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb110"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb110-1" data-line-number="1">sumEverySecond <span class="dv">6</span> <span class="fu">==&gt;</span> <span class="dv">12</span></a>
-<a class="sourceLine" id="cb110-2" data-line-number="2">sumEverySecond <span class="dv">7</span> <span class="fu">==&gt;</span> doesn&#39;t terminate</a></code></pre></div>
+<div class="sourceCode" id="cb109"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb109-1" title="1"><span class="co">-- computes sums like 7+5+3+1</span></a>
+<a class="sourceLine" id="cb109-2" title="2"><span class="ot">sumEverySecond ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb109-3" title="3">sumEverySecond <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb109-4" title="4">sumEverySecond n <span class="fu">=</span> n <span class="fu">+</span> sumEverySecond (n<span class="fu">-</span><span class="dv">2</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb110"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb110-1" title="1">sumEverySecond <span class="dv">6</span> <span class="fu">==&gt;</span> <span class="dv">12</span></a>
+<a class="sourceLine" id="cb110-2" title="2">sumEverySecond <span class="dv">7</span> <span class="fu">==&gt;</span> doesn&#39;t terminate</a></code></pre></div>
 <p>We can debug this by adding a <code>trace</code> to wrap the whole recursive case.</p>
-<div class="sourceCode" id="cb111"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb111-1" data-line-number="1"><span class="ot">sumEverySecond ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb111-2" data-line-number="2">sumEverySecond <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb111-3" data-line-number="3">sumEverySecond n <span class="fu">=</span> trace (<span class="st">&quot;sumEverySecond &quot;</span><span class="fu">++</span>show n) (n <span class="fu">+</span> sumEverySecond (n<span class="fu">-</span><span class="dv">2</span>))</a></code></pre></div>
-<div class="sourceCode" id="cb112"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb112-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> sumEverySecond <span class="dv">6</span></a>
-<a class="sourceLine" id="cb112-2" data-line-number="2">sumEverySecond <span class="dv">6</span></a>
-<a class="sourceLine" id="cb112-3" data-line-number="3">sumEverySecond <span class="dv">4</span></a>
-<a class="sourceLine" id="cb112-4" data-line-number="4">sumEverySecond <span class="dv">2</span></a>
-<a class="sourceLine" id="cb112-5" data-line-number="5"><span class="dv">12</span></a>
-<a class="sourceLine" id="cb112-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> sumEverySecond <span class="dv">7</span></a>
-<a class="sourceLine" id="cb112-7" data-line-number="7">sumEverySecond <span class="dv">7</span></a>
-<a class="sourceLine" id="cb112-8" data-line-number="8">sumEverySecond <span class="dv">5</span></a>
-<a class="sourceLine" id="cb112-9" data-line-number="9">sumEverySecond <span class="dv">3</span></a>
-<a class="sourceLine" id="cb112-10" data-line-number="10">sumEverySecond <span class="dv">1</span></a>
-<a class="sourceLine" id="cb112-11" data-line-number="11">sumEverySecond <span class="fu">-</span><span class="dv">1</span></a>
-<a class="sourceLine" id="cb112-12" data-line-number="12">sumEverySecond <span class="fu">-</span><span class="dv">3</span></a>
-<a class="sourceLine" id="cb112-13" data-line-number="13">sumEverySecond <span class="fu">-</span><span class="dv">5</span></a>
-<a class="sourceLine" id="cb112-14" data-line-number="14"><span class="co">-- and so on</span></a></code></pre></div>
+<div class="sourceCode" id="cb111"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb111-1" title="1"><span class="ot">sumEverySecond ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb111-2" title="2">sumEverySecond <span class="dv">0</span> <span class="fu">=</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb111-3" title="3">sumEverySecond n <span class="fu">=</span> trace (<span class="st">&quot;sumEverySecond &quot;</span><span class="fu">++show</span> n) (n <span class="fu">+</span> sumEverySecond (n<span class="fu">-</span><span class="dv">2</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb112"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb112-1" title="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> sumEverySecond <span class="dv">6</span></a>
+<a class="sourceLine" id="cb112-2" title="2">sumEverySecond <span class="dv">6</span></a>
+<a class="sourceLine" id="cb112-3" title="3">sumEverySecond <span class="dv">4</span></a>
+<a class="sourceLine" id="cb112-4" title="4">sumEverySecond <span class="dv">2</span></a>
+<a class="sourceLine" id="cb112-5" title="5"><span class="dv">12</span></a>
+<a class="sourceLine" id="cb112-6" title="6"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> sumEverySecond <span class="dv">7</span></a>
+<a class="sourceLine" id="cb112-7" title="7">sumEverySecond <span class="dv">7</span></a>
+<a class="sourceLine" id="cb112-8" title="8">sumEverySecond <span class="dv">5</span></a>
+<a class="sourceLine" id="cb112-9" title="9">sumEverySecond <span class="dv">3</span></a>
+<a class="sourceLine" id="cb112-10" title="10">sumEverySecond <span class="dv">1</span></a>
+<a class="sourceLine" id="cb112-11" title="11">sumEverySecond <span class="fu">-</span><span class="dv">1</span></a>
+<a class="sourceLine" id="cb112-12" title="12">sumEverySecond <span class="fu">-</span><span class="dv">3</span></a>
+<a class="sourceLine" id="cb112-13" title="13">sumEverySecond <span class="fu">-</span><span class="dv">5</span></a>
+<a class="sourceLine" id="cb112-14" title="14"><span class="co">-- and so on</span></a></code></pre></div>
 <p>A ha! The problem is that our recursion base case of <code>sumEverySecond 0</code> is not enough to stop the recursion.</p>
 <p>Finally, a word of caution. Using <code>trace</code>, and especially <code>traceShowId</code>, can cause things that would not otherwise get evaluated to get evaluated. For example:</p>
-<div class="sourceCode" id="cb113"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb113-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="kw">let</span> traceHead xs <span class="fu">=</span> head (traceShowId xs)</a>
-<a class="sourceLine" id="cb113-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> traceHead [<span class="dv">0</span><span class="fu">..</span>]</a>
-<a class="sourceLine" id="cb113-3" data-line-number="3"><span class="co">-- never terminates since it&#39;s trying to show an infinite list</span></a></code></pre></div>
+<div class="sourceCode" id="cb113"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb113-1" title="1"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> <span class="kw">let</span> traceHead xs <span class="fu">=</span> <span class="fu">head</span> (traceShowId xs)</a>
+<a class="sourceLine" id="cb113-2" title="2"><span class="dt">Prelude</span> <span class="dt">Debug.Trace</span><span class="fu">&gt;</span> traceHead [<span class="dv">0</span><span class="fu">..</span>]</a>
+<a class="sourceLine" id="cb113-3" title="3"><span class="co">-- never terminates since it&#39;s trying to show an infinite list</span></a></code></pre></div>
 <p>So feel free to use <code>Debug.Trace</code> when working on the exercises, but try to leave <code>trace</code> calls out of your final answers. Some exercise sets check your imports and disallow <code>Debug.Trace</code>.</p>
 <p>We’ll see a more principled way of dealing with side effects in the next lecture!</p>
 <h2 id="quiz-1"><span class="header-section-number">10.10</span> Quiz</h2>
@@ -1531,7 +1529,7 @@ pit-----&gt;|Room &quot;You fall...&quot; []|    treasure---&gt;|Room &quot;A gr
 </li>
 </ol>
 <p>What’s the next step when evaluating this expression?</p>
-<div class="sourceCode" id="cb114"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb114-1" data-line-number="1">head (map not (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a></code></pre></div>
+<div class="sourceCode" id="cb114"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb114-1" title="1"><span class="fu">head</span> (<span class="fu">map</span> <span class="fu">not</span> (<span class="dt">True</span><span class="fu">:</span><span class="dt">False</span><span class="fu">:</span>[]))</a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>head (False : True : [])</code>
@@ -1562,8 +1560,8 @@ pit-----&gt;|Room &quot;You fall...&quot; []|    treasure---&gt;|Room &quot;A gr
 </li>
 </ol>
 <p>Which of these statements about the following function is true?</p>
-<div class="sourceCode" id="cb115"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb115-1" data-line-number="1">f <span class="dv">0</span> x <span class="fu">=</span> <span class="dv">1</span><span class="fu">+</span>x</a>
-<a class="sourceLine" id="cb115-2" data-line-number="2">f _ x <span class="fu">=</span> <span class="dv">2</span><span class="fu">+</span>x</a></code></pre></div>
+<div class="sourceCode" id="cb115"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb115-1" title="1">f <span class="dv">0</span> x <span class="fu">=</span> <span class="dv">1</span><span class="fu">+</span>x</a>
+<a class="sourceLine" id="cb115-2" title="2">f _ x <span class="fu">=</span> <span class="dv">2</span><span class="fu">+</span>x</a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>f</code> is strict in its left argument
@@ -1579,8 +1577,8 @@ None of the above
 </li>
 </ol>
 <p>Does this function work with infinite lists as input? Why?</p>
-<div class="sourceCode" id="cb116"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb116-1" data-line-number="1">f [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb116-2" data-line-number="2">f (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">:</span> map not xs</a></code></pre></div>
+<div class="sourceCode" id="cb116"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb116-1" title="1">f [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb116-2" title="2">f (x<span class="fu">:</span>xs) <span class="fu">=</span> x <span class="fu">:</span> <span class="fu">map</span> <span class="fu">not</span> xs</a></code></pre></div>
 <ol class="quiz">
 <li>
 No, because it includes a <code>[]</code> case, which is never reached.
@@ -1596,7 +1594,7 @@ Yes, because it calls <code>map</code>, which works with infinite lists.
 </li>
 </ol>
 <p>What about this one?</p>
-<div class="sourceCode" id="cb117"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb117-1" data-line-number="1">f xs <span class="fu">=</span> map (<span class="fu">+</span>(sum xs)) xs</a></code></pre></div>
+<div class="sourceCode" id="cb117"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb117-1" title="1">f xs <span class="fu">=</span> <span class="fu">map</span> (<span class="fu">+</span>(<span class="fu">sum</span> xs)) xs</a></code></pre></div>
 <ol class="quiz">
 <li>
 No, because it uses <code>map</code>, which evaluates the whole list.
@@ -1624,24 +1622,24 @@ Yes, because it calls <code>map</code>, which works with infinite lists.
 </ul>
 <h2 id="youve-been-fooled"><span class="header-section-number">11.2</span> You’ve Been Fooled!</h2>
 <p>Forget what we talked about functional programming and purity. Actually, Haskell is the <em>world’s best imperative programming language</em>! Let’s start:</p>
-<div class="sourceCode" id="cb118"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb118-1" data-line-number="1">questionnaire <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb118-2" data-line-number="2">  putStrLn <span class="st">&quot;Write something!&quot;</span></a>
-<a class="sourceLine" id="cb118-3" data-line-number="3">  s <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb118-4" data-line-number="4">  putStrLn (<span class="st">&quot;You wrote: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
-<div class="sourceCode" id="cb119"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb119-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> questionnaire</a>
-<a class="sourceLine" id="cb119-2" data-line-number="2"><span class="dt">Write</span> something<span class="fu">!</span></a>
-<a class="sourceLine" id="cb119-3" data-line-number="3"><span class="dt">Haskell</span><span class="fu">!</span></a>
-<a class="sourceLine" id="cb119-4" data-line-number="4"><span class="dt">You</span> wrote<span class="fu">:</span> <span class="dt">Haskell</span><span class="fu">!</span></a></code></pre></div>
+<div class="sourceCode" id="cb118"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb118-1" title="1">questionnaire <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb118-2" title="2">  <span class="fu">putStrLn</span> <span class="st">&quot;Write something!&quot;</span></a>
+<a class="sourceLine" id="cb118-3" title="3">  s <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb118-4" title="4">  <span class="fu">putStrLn</span> (<span class="st">&quot;You wrote: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
+<div class="sourceCode" id="cb119"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb119-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> questionnaire</a>
+<a class="sourceLine" id="cb119-2" title="2"><span class="dt">Write</span> something<span class="fu">!</span></a>
+<a class="sourceLine" id="cb119-3" title="3"><span class="dt">Haskell</span><span class="fu">!</span></a>
+<a class="sourceLine" id="cb119-4" title="4"><span class="dt">You</span> wrote<span class="fu">:</span> <span class="dt">Haskell</span><span class="fu">!</span></a></code></pre></div>
 <p>Reading input and writing output was easy enough. We can also read stuff over the network. Here’s a complete Haskell program that fetches a some words from a URL using HTTP and prints them.</p>
-<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb120-1" data-line-number="1"><span class="kw">import</span> <span class="dt">Network.HTTP</span></a>
-<a class="sourceLine" id="cb120-2" data-line-number="2"><span class="kw">import</span> <span class="dt">Control.Monad</span></a>
-<a class="sourceLine" id="cb120-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb120-4" data-line-number="4">main <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb120-5" data-line-number="5">  rsp <span class="ot">&lt;-</span> simpleHTTP (getRequest <span class="st">&quot;http://httpbin.org/base64/aGFza2VsbCBmb3IgZXZlcgo=&quot;</span>)</a>
-<a class="sourceLine" id="cb120-6" data-line-number="6">  body <span class="ot">&lt;-</span> getResponseBody rsp</a>
-<a class="sourceLine" id="cb120-7" data-line-number="7">  forM_ (words body) <span class="fu">$</span> \w <span class="ot">-&gt;</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb120-8" data-line-number="8">     putStr <span class="st">&quot;word: &quot;</span></a>
-<a class="sourceLine" id="cb120-9" data-line-number="9">     putStrLn w</a></code></pre></div>
+<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb120-1" title="1"><span class="kw">import</span> <span class="dt">Network.HTTP</span></a>
+<a class="sourceLine" id="cb120-2" title="2"><span class="kw">import</span> <span class="dt">Control.Monad</span></a>
+<a class="sourceLine" id="cb120-3" title="3"></a>
+<a class="sourceLine" id="cb120-4" title="4">main <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb120-5" title="5">  rsp <span class="ot">&lt;-</span> simpleHTTP (getRequest <span class="st">&quot;http://httpbin.org/base64/aGFza2VsbCBmb3IgZXZlcgo=&quot;</span>)</a>
+<a class="sourceLine" id="cb120-6" title="6">  body <span class="ot">&lt;-</span> getResponseBody rsp</a>
+<a class="sourceLine" id="cb120-7" title="7">  forM_ (<span class="fu">words</span> body) <span class="fu">$</span> \w <span class="ot">-&gt;</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb120-8" title="8">     <span class="fu">putStr</span> <span class="st">&quot;word: &quot;</span></a>
+<a class="sourceLine" id="cb120-9" title="9">     <span class="fu">putStrLn</span> w</a></code></pre></div>
 <p>You can find this program in the course repository as <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/FetchWords.hs"><code>exercises/Examples/FetchWords.hs</code></a>, and you can run it like this:</p>
 <pre><code>$ cd exercises/Examples
 $ stack runhaskell FetchWords.hs
@@ -1649,10 +1647,10 @@ word: haskell
 word: for
 word: ever</code></pre>
 <p>What’s going on here? Let’s look at the types:</p>
-<div class="sourceCode" id="cb122"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb122-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t putStrLn</a>
-<a class="sourceLine" id="cb122-2" data-line-number="2">putStrLn<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb122-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t getLine</a>
-<a class="sourceLine" id="cb122-4" data-line-number="4">getLine<span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb122"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb122-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">putStrLn</span></a>
+<a class="sourceLine" id="cb122-2" title="2"><span class="fu">putStrLn</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb122-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb122-4" title="4"><span class="fu">getLine</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
 <p>A value of type <code>IO a</code> is an <em>operation</em> that <em>produces</em> a value of type <code>a</code>. So <code>getLine</code> is an IO operation that produces a string. The <code>()</code> type is the so called <em>unit type</em>, its only value is <code>()</code>. It’s mostly used when an IO operation doesn’t return anything (but rather just has side effects).</p>
 <p>A comparison with Java (method) types might help:</p>
 <table>
@@ -1682,93 +1680,93 @@ word: ever</code></pre>
 </tbody>
 </table>
 <p>IO operations can be combined into bigger operations using <em>do-notation</em>.</p>
-<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb123-1" data-line-number="1"><span class="kw">do</span> operation</a>
-<a class="sourceLine" id="cb123-2" data-line-number="2">   operation arg</a>
-<a class="sourceLine" id="cb123-3" data-line-number="3">   variable <span class="ot">&lt;-</span> operationThatReturnsStuff</a>
-<a class="sourceLine" id="cb123-4" data-line-number="4">   <span class="kw">let</span> var2 <span class="fu">=</span> expression</a>
-<a class="sourceLine" id="cb123-5" data-line-number="5">   operationThatProducesTheResult var2</a></code></pre></div>
+<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb123-1" title="1"><span class="kw">do</span> operation</a>
+<a class="sourceLine" id="cb123-2" title="2">   operation arg</a>
+<a class="sourceLine" id="cb123-3" title="3">   variable <span class="ot">&lt;-</span> operationThatReturnsStuff</a>
+<a class="sourceLine" id="cb123-4" title="4">   <span class="kw">let</span> var2 <span class="fu">=</span> expression</a>
+<a class="sourceLine" id="cb123-5" title="5">   operationThatProducesTheResult var2</a></code></pre></div>
 <h3 id="examples"><span class="header-section-number">11.2.1</span> Examples</h3>
 <p>You can find useful IO operations in the standard library modules <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Prelude.html">Prelude</a> and <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/System-IO.html">System.IO</a></p>
 <p>Here’s an IO operation that asks the user for a string, and prints out the length of the string.</p>
-<div class="sourceCode" id="cb124"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb124-1" data-line-number="1"><span class="ot">query ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb124-2" data-line-number="2">query <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb124-3" data-line-number="3">  putStrLn <span class="st">&quot;Write something!&quot;</span>                    <span class="co">-- run an operation, ignore produced value</span></a>
-<a class="sourceLine" id="cb124-4" data-line-number="4">  s <span class="ot">&lt;-</span> getLine                                   <span class="co">-- run an operation, capture produced value</span></a>
-<a class="sourceLine" id="cb124-5" data-line-number="5">  <span class="kw">let</span> n <span class="fu">=</span> length s                               <span class="co">-- run a pure function</span></a>
-<a class="sourceLine" id="cb124-6" data-line-number="6">  putStrLn (<span class="st">&quot;You wrote &quot;</span><span class="fu">++</span>show n<span class="fu">++</span><span class="st">&quot; characters&quot;</span>) <span class="co">-- run an operation, passing on the produced value</span></a></code></pre></div>
-<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb125-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> query</a>
-<a class="sourceLine" id="cb125-2" data-line-number="2"><span class="dt">Write</span> something<span class="fu">!</span></a>
-<a class="sourceLine" id="cb125-3" data-line-number="3">lorem ipsum</a>
-<a class="sourceLine" id="cb125-4" data-line-number="4"><span class="dt">You</span> wrote <span class="dv">11</span> characters</a></code></pre></div>
+<div class="sourceCode" id="cb124"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb124-1" title="1"><span class="ot">query ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb124-2" title="2">query <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb124-3" title="3">  <span class="fu">putStrLn</span> <span class="st">&quot;Write something!&quot;</span>                    <span class="co">-- run an operation, ignore produced value</span></a>
+<a class="sourceLine" id="cb124-4" title="4">  s <span class="ot">&lt;-</span> <span class="fu">getLine</span>                                   <span class="co">-- run an operation, capture produced value</span></a>
+<a class="sourceLine" id="cb124-5" title="5">  <span class="kw">let</span> n <span class="fu">=</span> <span class="fu">length</span> s                               <span class="co">-- run a pure function</span></a>
+<a class="sourceLine" id="cb124-6" title="6">  <span class="fu">putStrLn</span> (<span class="st">&quot;You wrote &quot;</span><span class="fu">++show</span> n<span class="fu">++</span><span class="st">&quot; characters&quot;</span>) <span class="co">-- run an operation, passing on the produced value</span></a></code></pre></div>
+<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb125-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> query</a>
+<a class="sourceLine" id="cb125-2" title="2"><span class="dt">Write</span> something<span class="fu">!</span></a>
+<a class="sourceLine" id="cb125-3" title="3">lorem ipsum</a>
+<a class="sourceLine" id="cb125-4" title="4"><span class="dt">You</span> wrote <span class="dv">11</span> characters</a></code></pre></div>
 <p>The value produced by the last line of a <code>do</code> block is the value produced by the whole block. Note how <code>askForALine</code> has the same type as <code>getLine</code>, <code>IO String</code>:</p>
-<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb126-1" data-line-number="1"><span class="ot">askForALine ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb126-2" data-line-number="2">askForALine <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb126-3" data-line-number="3">  putStrLn <span class="st">&quot;Please give me a line&quot;</span></a>
-<a class="sourceLine" id="cb126-4" data-line-number="4">  getLine</a></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb126-1" title="1"><span class="ot">askForALine ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb126-2" title="2">askForALine <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb126-3" title="3">  <span class="fu">putStrLn</span> <span class="st">&quot;Please give me a line&quot;</span></a>
+<a class="sourceLine" id="cb126-4" title="4">  <span class="fu">getLine</span></a></code></pre></div>
 <p>In addition to IO operations like <code>query</code> you can also run IO operations that produce values, like <code>askForALine</code>, in GHCi. You can use <code>&lt;-</code> to capture the result of the operation into a variable if you want.</p>
-<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb127-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> askForALine</a>
-<a class="sourceLine" id="cb127-2" data-line-number="2"><span class="dt">Please</span> give me a line</a>
-<a class="sourceLine" id="cb127-3" data-line-number="3">this is a line</a>
-<a class="sourceLine" id="cb127-4" data-line-number="4"><span class="st">&quot;this is a line&quot;</span></a>
-<a class="sourceLine" id="cb127-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> line <span class="ot">&lt;-</span> askForALine</a>
-<a class="sourceLine" id="cb127-6" data-line-number="6"><span class="dt">Please</span> give me a line</a>
-<a class="sourceLine" id="cb127-7" data-line-number="7">this is a line</a>
-<a class="sourceLine" id="cb127-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t line</a>
-<a class="sourceLine" id="cb127-9" data-line-number="9"><span class="ot">line ::</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb127-10" data-line-number="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> line</a>
-<a class="sourceLine" id="cb127-11" data-line-number="11"><span class="st">&quot;this is a line&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb127-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> askForALine</a>
+<a class="sourceLine" id="cb127-2" title="2"><span class="dt">Please</span> give me a line</a>
+<a class="sourceLine" id="cb127-3" title="3">this is a line</a>
+<a class="sourceLine" id="cb127-4" title="4"><span class="st">&quot;this is a line&quot;</span></a>
+<a class="sourceLine" id="cb127-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> line <span class="ot">&lt;-</span> askForALine</a>
+<a class="sourceLine" id="cb127-6" title="6"><span class="dt">Please</span> give me a line</a>
+<a class="sourceLine" id="cb127-7" title="7">this is a line</a>
+<a class="sourceLine" id="cb127-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t line</a>
+<a class="sourceLine" id="cb127-9" title="9"><span class="ot">line ::</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb127-10" title="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> line</a>
+<a class="sourceLine" id="cb127-11" title="11"><span class="st">&quot;this is a line&quot;</span></a></code></pre></div>
 <p>If you need to give your operation parameters, you can just make <em>a function that returns an operation</em>. Note how <code>ask</code> has a function type with a <code>-&gt;</code>, just like a normal function. We also use normal function definition syntax to give the parameter the name <code>question</code>.</p>
-<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb128-1" data-line-number="1"><span class="ot">ask ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb128-2" data-line-number="2">ask question <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb128-3" data-line-number="3">  putStrLn question</a>
-<a class="sourceLine" id="cb128-4" data-line-number="4">  getLine</a></code></pre></div>
-<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb129-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> ask <span class="st">&quot;What is love?&quot;</span></a>
-<a class="sourceLine" id="cb129-2" data-line-number="2"><span class="dt">What</span> is love<span class="fu">?</span></a>
-<a class="sourceLine" id="cb129-3" data-line-number="3"><span class="dt">Baby</span> don&#39;t hurt me<span class="fu">!</span></a>
-<a class="sourceLine" id="cb129-4" data-line-number="4"><span class="st">&quot;Baby don&#39;t hurt me!&quot;</span></a>
-<a class="sourceLine" id="cb129-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> response <span class="ot">&lt;-</span> ask <span class="st">&quot;Who are you?&quot;</span></a>
-<a class="sourceLine" id="cb129-6" data-line-number="6"><span class="dt">Who</span> are you<span class="fu">?</span></a>
-<a class="sourceLine" id="cb129-7" data-line-number="7"><span class="dt">The</span> programmer<span class="fu">.</span></a>
-<a class="sourceLine" id="cb129-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> response</a>
-<a class="sourceLine" id="cb129-9" data-line-number="9"><span class="st">&quot;The programmer.&quot;</span></a>
-<a class="sourceLine" id="cb129-10" data-line-number="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t response</a>
-<a class="sourceLine" id="cb129-11" data-line-number="11"><span class="ot">response ::</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb129-12" data-line-number="12"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t ask</a>
-<a class="sourceLine" id="cb129-13" data-line-number="13"><span class="ot">ask ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb129-14" data-line-number="14"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t ask <span class="st">&quot;Who are you?&quot;</span></a>
-<a class="sourceLine" id="cb129-15" data-line-number="15">ask <span class="st">&quot;Who are you?&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb128-1" title="1"><span class="ot">ask ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb128-2" title="2">ask question <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb128-3" title="3">  <span class="fu">putStrLn</span> question</a>
+<a class="sourceLine" id="cb128-4" title="4">  <span class="fu">getLine</span></a></code></pre></div>
+<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb129-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> ask <span class="st">&quot;What is love?&quot;</span></a>
+<a class="sourceLine" id="cb129-2" title="2"><span class="dt">What</span> is love<span class="fu">?</span></a>
+<a class="sourceLine" id="cb129-3" title="3"><span class="dt">Baby</span> don&#39;t hurt me<span class="fu">!</span></a>
+<a class="sourceLine" id="cb129-4" title="4"><span class="st">&quot;Baby don&#39;t hurt me!&quot;</span></a>
+<a class="sourceLine" id="cb129-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> response <span class="ot">&lt;-</span> ask <span class="st">&quot;Who are you?&quot;</span></a>
+<a class="sourceLine" id="cb129-6" title="6"><span class="dt">Who</span> are you<span class="fu">?</span></a>
+<a class="sourceLine" id="cb129-7" title="7"><span class="dt">The</span> programmer<span class="fu">.</span></a>
+<a class="sourceLine" id="cb129-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> response</a>
+<a class="sourceLine" id="cb129-9" title="9"><span class="st">&quot;The programmer.&quot;</span></a>
+<a class="sourceLine" id="cb129-10" title="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t response</a>
+<a class="sourceLine" id="cb129-11" title="11"><span class="ot">response ::</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb129-12" title="12"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t ask</a>
+<a class="sourceLine" id="cb129-13" title="13"><span class="ot">ask ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb129-14" title="14"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t ask <span class="st">&quot;Who are you?&quot;</span></a>
+<a class="sourceLine" id="cb129-15" title="15">ask <span class="st">&quot;Who are you?&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
 <h2 id="the-subtle-return"><span class="header-section-number">11.3</span> The Subtle <code>return</code></h2>
 <p>The Haskell function <code>return</code> is named a bit misleadingly. In other languages <code>return</code> is a built-in keyword, but in Haskell it’s just a function. The <code>return :: a -&gt; IO a</code> function takes a value and turns it into an <em>operation, that produces the value</em>.</p>
-<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb130-1" data-line-number="1"><span class="ot">produceThree ::</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb130-2" data-line-number="2">produceThree <span class="fu">=</span> return <span class="dv">3</span></a>
-<a class="sourceLine" id="cb130-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb130-4" data-line-number="4"><span class="ot">printThree ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb130-5" data-line-number="5">printThree <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb130-6" data-line-number="6">  three <span class="ot">&lt;-</span> produceThree</a>
-<a class="sourceLine" id="cb130-7" data-line-number="7">  putStrLn (show three)</a></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb130-1" title="1"><span class="ot">produceThree ::</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb130-2" title="2">produceThree <span class="fu">=</span> <span class="fu">return</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb130-3" title="3"></a>
+<a class="sourceLine" id="cb130-4" title="4"><span class="ot">printThree ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb130-5" title="5">printThree <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb130-6" title="6">  three <span class="ot">&lt;-</span> produceThree</a>
+<a class="sourceLine" id="cb130-7" title="7">  <span class="fu">putStrLn</span> (<span class="fu">show</span> three)</a></code></pre></div>
 <p>That doesn’t sound very useful does it? Combined with do-notation it is. Here we return a boolean according to whether the user answered <code>Y</code> or <code>N</code>:</p>
-<div class="sourceCode" id="cb131"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb131-1" data-line-number="1"><span class="ot">yesNoQuestion ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb131-2" data-line-number="2">yesNoQuestion question <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb131-3" data-line-number="3">  putStrLn question</a>
-<a class="sourceLine" id="cb131-4" data-line-number="4">  s <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb131-5" data-line-number="5">  return (s <span class="fu">==</span> <span class="st">&quot;Y&quot;</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb132"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb132-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> yesNoQuestion <span class="st">&quot;Fire the missiles?&quot;</span></a>
-<a class="sourceLine" id="cb132-2" data-line-number="2"><span class="dt">Fire</span> the missiles<span class="fu">?</span></a>
-<a class="sourceLine" id="cb132-3" data-line-number="3"><span class="dt">Y</span></a>
-<a class="sourceLine" id="cb132-4" data-line-number="4"><span class="dt">True</span></a>
-<a class="sourceLine" id="cb132-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer <span class="ot">&lt;-</span> yesNoQuestion <span class="st">&quot;Are you sure?&quot;</span></a>
-<a class="sourceLine" id="cb132-6" data-line-number="6"><span class="dt">Are</span> you sure<span class="fu">?</span></a>
-<a class="sourceLine" id="cb132-7" data-line-number="7"><span class="dt">N</span></a>
-<a class="sourceLine" id="cb132-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t answer</a>
-<a class="sourceLine" id="cb132-9" data-line-number="9"><span class="ot">answer ::</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb132-10" data-line-number="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer</a>
-<a class="sourceLine" id="cb132-11" data-line-number="11"><span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb131"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb131-1" title="1"><span class="ot">yesNoQuestion ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb131-2" title="2">yesNoQuestion question <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb131-3" title="3">  <span class="fu">putStrLn</span> question</a>
+<a class="sourceLine" id="cb131-4" title="4">  s <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb131-5" title="5">  <span class="fu">return</span> (s <span class="fu">==</span> <span class="st">&quot;Y&quot;</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb132"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb132-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> yesNoQuestion <span class="st">&quot;Fire the missiles?&quot;</span></a>
+<a class="sourceLine" id="cb132-2" title="2"><span class="dt">Fire</span> the missiles<span class="fu">?</span></a>
+<a class="sourceLine" id="cb132-3" title="3"><span class="dt">Y</span></a>
+<a class="sourceLine" id="cb132-4" title="4"><span class="dt">True</span></a>
+<a class="sourceLine" id="cb132-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer <span class="ot">&lt;-</span> yesNoQuestion <span class="st">&quot;Are you sure?&quot;</span></a>
+<a class="sourceLine" id="cb132-6" title="6"><span class="dt">Are</span> you sure<span class="fu">?</span></a>
+<a class="sourceLine" id="cb132-7" title="7"><span class="dt">N</span></a>
+<a class="sourceLine" id="cb132-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t answer</a>
+<a class="sourceLine" id="cb132-9" title="9"><span class="ot">answer ::</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb132-10" title="10"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer</a>
+<a class="sourceLine" id="cb132-11" title="11"><span class="dt">False</span></a></code></pre></div>
 <p><strong>Note!</strong> This means that return <em>does not stop execution</em> of an operation (unlike return in Java or C). Remember that in do-blocks, the last line decides which value to produce. This means that this operation produces <code>2</code>:</p>
-<div class="sourceCode" id="cb133"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb133-1" data-line-number="1"><span class="ot">produceTwo ::</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb133-2" data-line-number="2">produceTwo <span class="fu">=</span> <span class="kw">do</span> return <span class="dv">1</span></a>
-<a class="sourceLine" id="cb133-3" data-line-number="3">                return <span class="dv">2</span></a></code></pre></div>
-<div class="sourceCode" id="cb134"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb134-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> produceTwo</a>
-<a class="sourceLine" id="cb134-2" data-line-number="2"><span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb133"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb133-1" title="1"><span class="ot">produceTwo ::</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb133-2" title="2">produceTwo <span class="fu">=</span> <span class="kw">do</span> <span class="fu">return</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb133-3" title="3">                <span class="fu">return</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb134"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb134-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> produceTwo</a>
+<a class="sourceLine" id="cb134-2" title="2"><span class="dv">2</span></a></code></pre></div>
 <p>Let’s look at this another way. The <code>do</code> notation allows us to cause a sequence of side-effects, and finally to produce a value.</p>
 <pre><code>produceThree = do putStrLn &quot;1&quot;   -- side effect, produces (), which is ignored
                   return    2    -- no side effect, produces 2, which is ignored
@@ -1780,328 +1778,328 @@ this line is ignored
 Prelude&gt; final
 3</code></pre>
 <p>Also note that these are the same operation:</p>
-<div class="sourceCode" id="cb137"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb137-1" data-line-number="1"><span class="kw">do</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb137-2" data-line-number="2">   x <span class="ot">&lt;-</span> op</a>
-<a class="sourceLine" id="cb137-3" data-line-number="3">   return x</a></code></pre></div>
-<div class="sourceCode" id="cb138"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb138-1" data-line-number="1"><span class="kw">do</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb138-2" data-line-number="2">   op</a></code></pre></div>
+<div class="sourceCode" id="cb137"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb137-1" title="1"><span class="kw">do</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb137-2" title="2">   x <span class="ot">&lt;-</span> op</a>
+<a class="sourceLine" id="cb137-3" title="3">   <span class="fu">return</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb138"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb138-1" title="1"><span class="kw">do</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb138-2" title="2">   op</a></code></pre></div>
 <p>Since <code>return</code> is a function, you should remember to parenthesize any complex expressions:</p>
-<div class="sourceCode" id="cb139"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb139-1" data-line-number="1">return (f x <span class="fu">:</span> xs)</a>
-<a class="sourceLine" id="cb139-2" data-line-number="2"><span class="co">-- alternatively:</span></a>
-<a class="sourceLine" id="cb139-3" data-line-number="3">return <span class="fu">$</span> f x <span class="fu">:</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb139"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb139-1" title="1"><span class="fu">return</span> (f x <span class="fu">:</span> xs)</a>
+<a class="sourceLine" id="cb139-2" title="2"><span class="co">-- alternatively:</span></a>
+<a class="sourceLine" id="cb139-3" title="3"><span class="fu">return</span> <span class="fu">$</span> f x <span class="fu">:</span> xs</a></code></pre></div>
 <h2 id="do-and-types"><span class="header-section-number">11.4</span> <code>do</code> and Types</h2>
 <p>Let’s look at the typing of do-notation in more detail. A do-block builds a value of type <code>IO &lt;something&gt;</code>. For example in</p>
-<div class="sourceCode" id="cb140"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb140-1" data-line-number="1">foo <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb140-2" data-line-number="2">  <span class="fu">...</span></a>
-<a class="sourceLine" id="cb140-3" data-line-number="3">  lastOp</a></code></pre></div>
+<div class="sourceCode" id="cb140"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb140-1" title="1">foo <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb140-2" title="2">  <span class="fu">...</span></a>
+<a class="sourceLine" id="cb140-3" title="3">  lastOp</a></code></pre></div>
 <p>The <code>lastOp</code> must be of type <code>IO X</code> (for some <code>X</code>). The type of <code>foo</code> will also be <code>IO X</code>. Let’s look at an example with parameters next:</p>
-<div class="sourceCode" id="cb141"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb141-1" data-line-number="1">bar x y <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb141-2" data-line-number="2">  <span class="fu">...</span></a>
-<a class="sourceLine" id="cb141-3" data-line-number="3">  lastOp arg</a></code></pre></div>
+<div class="sourceCode" id="cb141"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb141-1" title="1">bar x y <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb141-2" title="2">  <span class="fu">...</span></a>
+<a class="sourceLine" id="cb141-3" title="3">  lastOp arg</a></code></pre></div>
 <p>The <code>lastOp</code> must be of type <code>Y -&gt; IO X</code> (so that <code>lastOp arg</code> has type <code>IO X</code>). The type of <code>bar</code> will be <code>A -&gt; B -&gt; IO X</code> (and inside <code>bar</code> we’ll have <code>x :: A</code> and <code>y :: B</code>).</p>
 <p>If we use <code>return</code>:</p>
-<div class="sourceCode" id="cb142"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb142-1" data-line-number="1">quux x <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb142-2" data-line-number="2">  <span class="fu">...</span></a>
-<a class="sourceLine" id="cb142-3" data-line-number="3">  return value</a></code></pre></div>
+<div class="sourceCode" id="cb142"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb142-1" title="1">quux x <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb142-2" title="2">  <span class="fu">...</span></a>
+<a class="sourceLine" id="cb142-3" title="3">  <span class="fu">return</span> value</a></code></pre></div>
 <p>The function <code>quux</code> will have type <code>A -&gt; IO B</code>, where <code>x :: A</code> and <code>value :: B</code>.</p>
 <p>Let’s look at the typing of <code>&lt;-</code> next. If <code>op :: IO X</code> and you have <code>var &lt;- op</code>, <code>var</code> will have type <code>X</code>. We’ve seen this in many GHCi examples.</p>
 <p>The last line of a <code>do</code> cannot be <code>foo &lt;- bar</code>. It can’t be <code>let foo = bar</code> either. The last line determines what the whole operation produces, so it must be an operation (for example, <code>return something</code>).</p>
 <p>Here’s a worked example:</p>
-<div class="sourceCode" id="cb143"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb143-1" data-line-number="1"><span class="ot">alwaysFine ::</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb143-2" data-line-number="2">alwaysFine <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb143-3" data-line-number="3">  putStrLn <span class="st">&quot;What?&quot;</span> <span class="co">-- :: IO ()</span></a>
-<a class="sourceLine" id="cb143-4" data-line-number="4">  return <span class="dv">2</span>         <span class="co">-- :: IO Int, produced value is discarded</span></a>
-<a class="sourceLine" id="cb143-5" data-line-number="5">  s <span class="ot">&lt;-</span> getLine     <span class="co">-- getLine :: IO String, thus s :: String</span></a>
-<a class="sourceLine" id="cb143-6" data-line-number="6">  putStrLn s       <span class="co">-- putStrLn :: String -&gt; IO (), thus putStrLn s :: IO ()</span></a>
-<a class="sourceLine" id="cb143-7" data-line-number="7">  <span class="kw">let</span> b <span class="fu">=</span> <span class="dt">True</span>     <span class="co">-- b :: Bool</span></a>
-<a class="sourceLine" id="cb143-8" data-line-number="8">  return b         <span class="co">-- :: IO Bool</span></a>
-<a class="sourceLine" id="cb143-9" data-line-number="9">                   <span class="co">-- Thus, alwaysFine :: IO Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb143"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb143-1" title="1"><span class="ot">alwaysFine ::</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb143-2" title="2">alwaysFine <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb143-3" title="3">  <span class="fu">putStrLn</span> <span class="st">&quot;What?&quot;</span> <span class="co">-- :: IO ()</span></a>
+<a class="sourceLine" id="cb143-4" title="4">  <span class="fu">return</span> <span class="dv">2</span>         <span class="co">-- :: IO Int, produced value is discarded</span></a>
+<a class="sourceLine" id="cb143-5" title="5">  s <span class="ot">&lt;-</span> <span class="fu">getLine</span>     <span class="co">-- getLine :: IO String, thus s :: String</span></a>
+<a class="sourceLine" id="cb143-6" title="6">  <span class="fu">putStrLn</span> s       <span class="co">-- putStrLn :: String -&gt; IO (), thus putStrLn s :: IO ()</span></a>
+<a class="sourceLine" id="cb143-7" title="7">  <span class="kw">let</span> b <span class="fu">=</span> <span class="dt">True</span>     <span class="co">-- b :: Bool</span></a>
+<a class="sourceLine" id="cb143-8" title="8">  <span class="fu">return</span> b         <span class="co">-- :: IO Bool</span></a>
+<a class="sourceLine" id="cb143-9" title="9">                   <span class="co">-- Thus, alwaysFine :: IO Bool</span></a></code></pre></div>
 <p>The typing rules guarantee that you can not “escape” <code>IO</code>. Even though <code>&lt;-</code> gives you an <code>X</code> from an <code>IO X</code>, you can only use <code>&lt;-</code> inside <code>do</code>. However a <code>do</code> always means a value of type <code>IO Y</code>. In other words: you can temporarily open the <code>IO</code> box, but you must return into it. <em>“What happens in IO, stays in IO.”</em></p>
 <p>We’ll talk more about what this means later. For now, it’s enough to know that if you have a function with a non-IO type, like for example <code>myFunction :: Int -&gt; [String] -&gt; String</code>, the function can not have IO happening inside it. It is a pure function.</p>
 <h2 id="control-structures"><span class="header-section-number">11.5</span> Control Structures</h2>
 <p>For the following examples, we’ll need two new operations.</p>
-<div class="sourceCode" id="cb144"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb144-1" data-line-number="1">print<span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- print a value using the show function</span></a>
-<a class="sourceLine" id="cb144-2" data-line-number="2">readLn<span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">IO</span> a        <span class="co">-- get a line and convert it to a value using the read function</span></a></code></pre></div>
+<div class="sourceCode" id="cb144"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb144-1" title="1"><span class="fu">print</span><span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- print a value using the show function</span></a>
+<a class="sourceLine" id="cb144-2" title="2"><span class="fu">readLn</span><span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">IO</span> a        <span class="co">-- get a line and convert it to a value using the read function</span></a></code></pre></div>
 <p>The usual tools of recursion, guards and if-then-else also work in the <code>IO</code> world. Here’s an IO operation that’s defined using a guard:</p>
-<div class="sourceCode" id="cb145"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb145-1" data-line-number="1"><span class="ot">printDescription ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb145-2" data-line-number="2">printDescription n</a>
-<a class="sourceLine" id="cb145-3" data-line-number="3">  <span class="fu">|</span> even n    <span class="fu">=</span> putStrLn <span class="st">&quot;even&quot;</span></a>
-<a class="sourceLine" id="cb145-4" data-line-number="4">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">3</span>      <span class="fu">=</span> putStrLn <span class="st">&quot;three&quot;</span></a>
-<a class="sourceLine" id="cb145-5" data-line-number="5">  <span class="fu">|</span> otherwise <span class="fu">=</span> print n</a></code></pre></div>
-<div class="sourceCode" id="cb146"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb146-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">2</span></a>
-<a class="sourceLine" id="cb146-2" data-line-number="2">even</a>
-<a class="sourceLine" id="cb146-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">3</span></a>
-<a class="sourceLine" id="cb146-4" data-line-number="4">three</a>
-<a class="sourceLine" id="cb146-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">5</span></a>
-<a class="sourceLine" id="cb146-6" data-line-number="6"><span class="dv">5</span></a></code></pre></div>
+<div class="sourceCode" id="cb145"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb145-1" title="1"><span class="ot">printDescription ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb145-2" title="2">printDescription n</a>
+<a class="sourceLine" id="cb145-3" title="3">  <span class="fu">|</span> <span class="fu">even</span> n    <span class="fu">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;even&quot;</span></a>
+<a class="sourceLine" id="cb145-4" title="4">  <span class="fu">|</span> n<span class="fu">==</span><span class="dv">3</span>      <span class="fu">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;three&quot;</span></a>
+<a class="sourceLine" id="cb145-5" title="5">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="fu">print</span> n</a></code></pre></div>
+<div class="sourceCode" id="cb146"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb146-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">2</span></a>
+<a class="sourceLine" id="cb146-2" title="2"><span class="fu">even</span></a>
+<a class="sourceLine" id="cb146-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">3</span></a>
+<a class="sourceLine" id="cb146-4" title="4">three</a>
+<a class="sourceLine" id="cb146-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> printDescription <span class="dv">5</span></a>
+<a class="sourceLine" id="cb146-6" title="6"><span class="dv">5</span></a></code></pre></div>
 <p>Here’s an operation that prints all numbers in a list using recursion and pattern matching:</p>
-<div class="sourceCode" id="cb147"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb147-1" data-line-number="1"><span class="ot">printList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb147-2" data-line-number="2">printList [] <span class="fu">=</span> return () <span class="co">-- do nothing</span></a>
-<a class="sourceLine" id="cb147-3" data-line-number="3">printList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> print x</a>
-<a class="sourceLine" id="cb147-4" data-line-number="4">                      printList xs <span class="co">-- recursion</span></a></code></pre></div>
-<div class="sourceCode" id="cb148"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb148-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb148-2" data-line-number="2"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb148-3" data-line-number="3"><span class="dv">2</span></a>
-<a class="sourceLine" id="cb148-4" data-line-number="4"><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb147"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb147-1" title="1"><span class="ot">printList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb147-2" title="2">printList [] <span class="fu">=</span> <span class="fu">return</span> () <span class="co">-- do nothing</span></a>
+<a class="sourceLine" id="cb147-3" title="3">printList (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> <span class="fu">print</span> x</a>
+<a class="sourceLine" id="cb147-4" title="4">                      printList xs <span class="co">-- recursion</span></a></code></pre></div>
+<div class="sourceCode" id="cb148"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb148-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printList [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb148-2" title="2"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb148-3" title="3"><span class="dv">2</span></a>
+<a class="sourceLine" id="cb148-4" title="4"><span class="dv">3</span></a></code></pre></div>
 <p>Here are two slightly more complicated examples of recursive IO operations. They use the value produced by the recursive call. The operation <code>readAndSum n</code> reads <code>n</code> numbers from the user and prints their sum. The operation <code>ask questions</code> shows each string in <code>questions</code> to the user, reads a response, and returns a list of all the responses.</p>
-<div class="sourceCode" id="cb149"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb149-1" data-line-number="1"><span class="ot">readAndSum ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb149-2" data-line-number="2">readAndSum <span class="dv">0</span> <span class="fu">=</span> return <span class="dv">0</span></a>
-<a class="sourceLine" id="cb149-3" data-line-number="3">readAndSum n <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb149-4" data-line-number="4">  i <span class="ot">&lt;-</span> readLn            <span class="co">-- read one number</span></a>
-<a class="sourceLine" id="cb149-5" data-line-number="5">  s <span class="ot">&lt;-</span> readAndSum (n<span class="fu">-</span><span class="dv">1</span>)  <span class="co">-- recursion: read and sum rest of numbers</span></a>
-<a class="sourceLine" id="cb149-6" data-line-number="6">  return (i<span class="fu">+</span>s)           <span class="co">-- produce result</span></a></code></pre></div>
-<div class="sourceCode" id="cb150"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb150-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> s <span class="ot">&lt;-</span> readAndSum <span class="dv">3</span></a>
-<a class="sourceLine" id="cb150-2" data-line-number="2"><span class="dv">2</span></a>
-<a class="sourceLine" id="cb150-3" data-line-number="3"><span class="dv">4</span></a>
-<a class="sourceLine" id="cb150-4" data-line-number="4"><span class="dv">5</span></a>
-<a class="sourceLine" id="cb150-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> s</a>
-<a class="sourceLine" id="cb150-6" data-line-number="6"><span class="dv">11</span></a></code></pre></div>
-<div class="sourceCode" id="cb151"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb151-1" data-line-number="1"><span class="ot">ask ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb151-2" data-line-number="2">ask [] <span class="fu">=</span> return []</a>
-<a class="sourceLine" id="cb151-3" data-line-number="3">ask (question<span class="fu">:</span>questions) <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb151-4" data-line-number="4">  putStr question</a>
-<a class="sourceLine" id="cb151-5" data-line-number="5">  putStrLn <span class="st">&quot;?&quot;</span></a>
-<a class="sourceLine" id="cb151-6" data-line-number="6">  answer <span class="ot">&lt;-</span> getLine         <span class="co">-- get one answer</span></a>
-<a class="sourceLine" id="cb151-7" data-line-number="7">  answers <span class="ot">&lt;-</span> ask questions  <span class="co">-- recursion: get rest of answers</span></a>
-<a class="sourceLine" id="cb151-8" data-line-number="8">  return (answer<span class="fu">:</span>answers)   <span class="co">-- produce result</span></a></code></pre></div>
-<div class="sourceCode" id="cb152"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb152-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> replies <span class="ot">&lt;-</span> ask [<span class="st">&quot;What is your name&quot;</span>,<span class="st">&quot;How old are you&quot;</span>]</a>
-<a class="sourceLine" id="cb152-2" data-line-number="2"><span class="dt">What</span> is your name<span class="fu">?</span></a>
-<a class="sourceLine" id="cb152-3" data-line-number="3"><span class="dt">Yog</span><span class="fu">-</span><span class="dt">Sothoth</span></a>
-<a class="sourceLine" id="cb152-4" data-line-number="4"><span class="dt">How</span> old are you<span class="fu">?</span></a>
-<a class="sourceLine" id="cb152-5" data-line-number="5"><span class="dt">The</span> question is meaningless</a>
-<a class="sourceLine" id="cb152-6" data-line-number="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> replies</a>
-<a class="sourceLine" id="cb152-7" data-line-number="7">[<span class="st">&quot;Yog-Sothoth&quot;</span>,<span class="st">&quot;The question is meaningless&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb149"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb149-1" title="1"><span class="ot">readAndSum ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb149-2" title="2">readAndSum <span class="dv">0</span> <span class="fu">=</span> <span class="fu">return</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb149-3" title="3">readAndSum n <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb149-4" title="4">  i <span class="ot">&lt;-</span> <span class="fu">readLn</span>            <span class="co">-- read one number</span></a>
+<a class="sourceLine" id="cb149-5" title="5">  s <span class="ot">&lt;-</span> readAndSum (n<span class="fu">-</span><span class="dv">1</span>)  <span class="co">-- recursion: read and sum rest of numbers</span></a>
+<a class="sourceLine" id="cb149-6" title="6">  <span class="fu">return</span> (i<span class="fu">+</span>s)           <span class="co">-- produce result</span></a></code></pre></div>
+<div class="sourceCode" id="cb150"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb150-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> s <span class="ot">&lt;-</span> readAndSum <span class="dv">3</span></a>
+<a class="sourceLine" id="cb150-2" title="2"><span class="dv">2</span></a>
+<a class="sourceLine" id="cb150-3" title="3"><span class="dv">4</span></a>
+<a class="sourceLine" id="cb150-4" title="4"><span class="dv">5</span></a>
+<a class="sourceLine" id="cb150-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> s</a>
+<a class="sourceLine" id="cb150-6" title="6"><span class="dv">11</span></a></code></pre></div>
+<div class="sourceCode" id="cb151"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb151-1" title="1"><span class="ot">ask ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb151-2" title="2">ask [] <span class="fu">=</span> <span class="fu">return</span> []</a>
+<a class="sourceLine" id="cb151-3" title="3">ask (question<span class="fu">:</span>questions) <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb151-4" title="4">  <span class="fu">putStr</span> question</a>
+<a class="sourceLine" id="cb151-5" title="5">  <span class="fu">putStrLn</span> <span class="st">&quot;?&quot;</span></a>
+<a class="sourceLine" id="cb151-6" title="6">  answer <span class="ot">&lt;-</span> <span class="fu">getLine</span>         <span class="co">-- get one answer</span></a>
+<a class="sourceLine" id="cb151-7" title="7">  answers <span class="ot">&lt;-</span> ask questions  <span class="co">-- recursion: get rest of answers</span></a>
+<a class="sourceLine" id="cb151-8" title="8">  <span class="fu">return</span> (answer<span class="fu">:</span>answers)   <span class="co">-- produce result</span></a></code></pre></div>
+<div class="sourceCode" id="cb152"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb152-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> replies <span class="ot">&lt;-</span> ask [<span class="st">&quot;What is your name&quot;</span>,<span class="st">&quot;How old are you&quot;</span>]</a>
+<a class="sourceLine" id="cb152-2" title="2"><span class="dt">What</span> is your name<span class="fu">?</span></a>
+<a class="sourceLine" id="cb152-3" title="3"><span class="dt">Yog</span><span class="fu">-</span><span class="dt">Sothoth</span></a>
+<a class="sourceLine" id="cb152-4" title="4"><span class="dt">How</span> old are you<span class="fu">?</span></a>
+<a class="sourceLine" id="cb152-5" title="5"><span class="dt">The</span> question is meaningless</a>
+<a class="sourceLine" id="cb152-6" title="6"><span class="dt">Prelude</span><span class="fu">&gt;</span> replies</a>
+<a class="sourceLine" id="cb152-7" title="7">[<span class="st">&quot;Yog-Sothoth&quot;</span>,<span class="st">&quot;The question is meaningless&quot;</span>]</a></code></pre></div>
 <p>Additionally, we have some <code>IO</code>-specific control structures, or rather, functions. These come from the module <code>Control.Monad</code>.</p>
-<div class="sourceCode" id="cb153"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb153-1" data-line-number="1"><span class="co">-- when b op performs op if b is true</span></a>
-<a class="sourceLine" id="cb153-2" data-line-number="2"><span class="ot">when ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb153-3" data-line-number="3"><span class="co">-- unless b op performs op if b is false</span></a>
-<a class="sourceLine" id="cb153-4" data-line-number="4"><span class="ot">unless ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb153-5" data-line-number="5"><span class="co">-- do something many times, collect results</span></a>
-<a class="sourceLine" id="cb153-6" data-line-number="6"><span class="ot">replicateM ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> [a]</a>
-<a class="sourceLine" id="cb153-7" data-line-number="7"><span class="co">-- do something many times, throw away the results</span></a>
-<a class="sourceLine" id="cb153-8" data-line-number="8"><span class="ot">replicateM_ ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb153-9" data-line-number="9"><span class="co">-- do something for every list element</span></a>
-<a class="sourceLine" id="cb153-10" data-line-number="10">mapM<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> [b]</a>
-<a class="sourceLine" id="cb153-11" data-line-number="11"><span class="co">-- do something for every list element, throw away the results</span></a>
-<a class="sourceLine" id="cb153-12" data-line-number="12">mapM_<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb153-13" data-line-number="13"><span class="co">-- the same, but arguments flipped</span></a>
-<a class="sourceLine" id="cb153-14" data-line-number="14"><span class="ot">forM  ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> [b]</a>
-<a class="sourceLine" id="cb153-15" data-line-number="15"><span class="ot">forM_ ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
+<div class="sourceCode" id="cb153"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb153-1" title="1"><span class="co">-- when b op performs op if b is true</span></a>
+<a class="sourceLine" id="cb153-2" title="2"><span class="ot">when ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb153-3" title="3"><span class="co">-- unless b op performs op if b is false</span></a>
+<a class="sourceLine" id="cb153-4" title="4"><span class="ot">unless ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb153-5" title="5"><span class="co">-- do something many times, collect results</span></a>
+<a class="sourceLine" id="cb153-6" title="6"><span class="ot">replicateM ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> [a]</a>
+<a class="sourceLine" id="cb153-7" title="7"><span class="co">-- do something many times, throw away the results</span></a>
+<a class="sourceLine" id="cb153-8" title="8"><span class="ot">replicateM_ ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb153-9" title="9"><span class="co">-- do something for every list element</span></a>
+<a class="sourceLine" id="cb153-10" title="10"><span class="fu">mapM</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> [b]</a>
+<a class="sourceLine" id="cb153-11" title="11"><span class="co">-- do something for every list element, throw away the results</span></a>
+<a class="sourceLine" id="cb153-12" title="12"><span class="fu">mapM_</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb153-13" title="13"><span class="co">-- the same, but arguments flipped</span></a>
+<a class="sourceLine" id="cb153-14" title="14"><span class="ot">forM  ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> [b]</a>
+<a class="sourceLine" id="cb153-15" title="15"><span class="ot">forM_ ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
 <p>Using these, we can rewrite our earlier examples:</p>
-<div class="sourceCode" id="cb154"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb154-1" data-line-number="1"><span class="ot">printList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb154-2" data-line-number="2">printList xs <span class="fu">=</span> mapM_ print xs</a></code></pre></div>
-<div class="sourceCode" id="cb155"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb155-1" data-line-number="1">readAndSum n <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb155-2" data-line-number="2">  numbers <span class="ot">&lt;-</span> replicateM n readLn</a>
-<a class="sourceLine" id="cb155-3" data-line-number="3">  return (sum numbers)</a></code></pre></div>
-<div class="sourceCode" id="cb156"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb156-1" data-line-number="1"><span class="ot">ask ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb156-2" data-line-number="2">ask questions <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb156-3" data-line-number="3">  forM questions askOne</a>
-<a class="sourceLine" id="cb156-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb156-5" data-line-number="5"><span class="ot">askOne ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb156-6" data-line-number="6">askOne question <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb156-7" data-line-number="7">  putStr question</a>
-<a class="sourceLine" id="cb156-8" data-line-number="8">  putStrLn <span class="st">&quot;?&quot;</span></a>
-<a class="sourceLine" id="cb156-9" data-line-number="9">  getLine</a></code></pre></div>
+<div class="sourceCode" id="cb154"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb154-1" title="1"><span class="ot">printList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb154-2" title="2">printList xs <span class="fu">=</span> <span class="fu">mapM_</span> <span class="fu">print</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb155"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb155-1" title="1">readAndSum n <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb155-2" title="2">  numbers <span class="ot">&lt;-</span> replicateM n <span class="fu">readLn</span></a>
+<a class="sourceLine" id="cb155-3" title="3">  <span class="fu">return</span> (<span class="fu">sum</span> numbers)</a></code></pre></div>
+<div class="sourceCode" id="cb156"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb156-1" title="1"><span class="ot">ask ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb156-2" title="2">ask questions <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb156-3" title="3">  forM questions askOne</a>
+<a class="sourceLine" id="cb156-4" title="4"></a>
+<a class="sourceLine" id="cb156-5" title="5"><span class="ot">askOne ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb156-6" title="6">askOne question <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb156-7" title="7">  <span class="fu">putStr</span> question</a>
+<a class="sourceLine" id="cb156-8" title="8">  <span class="fu">putStrLn</span> <span class="st">&quot;?&quot;</span></a>
+<a class="sourceLine" id="cb156-9" title="9">  <span class="fu">getLine</span></a></code></pre></div>
 <h2 id="a-word-about-do-and-indentation"><span class="header-section-number">11.6</span> A Word About <code>do</code> and Indentation</h2>
 <p>It’s easy to run into weird indentation problems when using do-notation. Here are some rules of thumb to help you get it right.</p>
 <p>The most important rule of do and indentation is <em>all operations in a do-block must start in the same column</em>.</p>
 <p>Some examples of this rule:</p>
-<div class="sourceCode" id="cb157"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb157-1" data-line-number="1"><span class="co">-- This is not OK, putStrLn is way too left</span></a>
-<a class="sourceLine" id="cb157-2" data-line-number="2">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb157-3" data-line-number="3">   putStrLn y</a>
-<a class="sourceLine" id="cb157-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb157-5" data-line-number="5"><span class="co">-- This is not OK either</span></a>
-<a class="sourceLine" id="cb157-6" data-line-number="6">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb157-7" data-line-number="7">           putStrLn y</a>
-<a class="sourceLine" id="cb157-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb157-9" data-line-number="9"><span class="co">-- This is OK</span></a>
-<a class="sourceLine" id="cb157-10" data-line-number="10">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb157-11" data-line-number="11">         putStrLn y</a>
-<a class="sourceLine" id="cb157-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb157-13" data-line-number="13"><span class="co">-- This is also OK: putting a line break after do</span></a>
-<a class="sourceLine" id="cb157-14" data-line-number="14">foo <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb157-15" data-line-number="15">  y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb157-16" data-line-number="16">  putStrLn y</a></code></pre></div>
+<div class="sourceCode" id="cb157"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb157-1" title="1"><span class="co">-- This is not OK, putStrLn is way too left</span></a>
+<a class="sourceLine" id="cb157-2" title="2">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb157-3" title="3">   <span class="fu">putStrLn</span> y</a>
+<a class="sourceLine" id="cb157-4" title="4"></a>
+<a class="sourceLine" id="cb157-5" title="5"><span class="co">-- This is not OK either</span></a>
+<a class="sourceLine" id="cb157-6" title="6">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb157-7" title="7">           <span class="fu">putStrLn</span> y</a>
+<a class="sourceLine" id="cb157-8" title="8"></a>
+<a class="sourceLine" id="cb157-9" title="9"><span class="co">-- This is OK</span></a>
+<a class="sourceLine" id="cb157-10" title="10">foo <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb157-11" title="11">         <span class="fu">putStrLn</span> y</a>
+<a class="sourceLine" id="cb157-12" title="12"></a>
+<a class="sourceLine" id="cb157-13" title="13"><span class="co">-- This is also OK: putting a line break after do</span></a>
+<a class="sourceLine" id="cb157-14" title="14">foo <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb157-15" title="15">  y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb157-16" title="16">  <span class="fu">putStrLn</span> y</a></code></pre></div>
 <p>A related rule is <em>when an operation goes over multiple lines, indent the follow-up lines</em>. If you don’t indent, it’ll look like a new operation!</p>
-<div class="sourceCode" id="cb158"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb158-1" data-line-number="1"><span class="co">-- This is not OK, the string starts a new operation</span></a>
-<a class="sourceLine" id="cb158-2" data-line-number="2">quux <span class="fu">=</span> <span class="kw">do</span> putStrLn</a>
-<a class="sourceLine" id="cb158-3" data-line-number="3">          <span class="st">&quot;this long string&quot;</span></a>
-<a class="sourceLine" id="cb158-4" data-line-number="4">          print <span class="dv">1</span></a>
-<a class="sourceLine" id="cb158-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb158-6" data-line-number="6"><span class="co">-- This is OK</span></a>
-<a class="sourceLine" id="cb158-7" data-line-number="7">quux <span class="fu">=</span> <span class="kw">do</span> putStrLn</a>
-<a class="sourceLine" id="cb158-8" data-line-number="8">            <span class="st">&quot;this long string&quot;</span></a>
-<a class="sourceLine" id="cb158-9" data-line-number="9">          print <span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb158"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb158-1" title="1"><span class="co">-- This is not OK, the string starts a new operation</span></a>
+<a class="sourceLine" id="cb158-2" title="2">quux <span class="fu">=</span> <span class="kw">do</span> <span class="fu">putStrLn</span></a>
+<a class="sourceLine" id="cb158-3" title="3">          <span class="st">&quot;this long string&quot;</span></a>
+<a class="sourceLine" id="cb158-4" title="4">          <span class="fu">print</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb158-5" title="5"></a>
+<a class="sourceLine" id="cb158-6" title="6"><span class="co">-- This is OK</span></a>
+<a class="sourceLine" id="cb158-7" title="7">quux <span class="fu">=</span> <span class="kw">do</span> <span class="fu">putStrLn</span></a>
+<a class="sourceLine" id="cb158-8" title="8">            <span class="st">&quot;this long string&quot;</span></a>
+<a class="sourceLine" id="cb158-9" title="9">          <span class="fu">print</span> <span class="dv">1</span></a></code></pre></div>
 <p>Here’s one more example, with nested do-blocks, and two different valid indentations.</p>
-<div class="sourceCode" id="cb159"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb159-1" data-line-number="1"><span class="co">-- This is OK</span></a>
-<a class="sourceLine" id="cb159-2" data-line-number="2">foo x <span class="fu">=</span> <span class="kw">do</span> quux</a>
-<a class="sourceLine" id="cb159-3" data-line-number="3">           y <span class="ot">&lt;-</span> blorg</a>
-<a class="sourceLine" id="cb159-4" data-line-number="4">           when y (<span class="kw">do</span> thing</a>
-<a class="sourceLine" id="cb159-5" data-line-number="5">                      otherThing)</a>
-<a class="sourceLine" id="cb159-6" data-line-number="6">           return <span class="dv">3</span></a>
-<a class="sourceLine" id="cb159-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb159-8" data-line-number="8"><span class="co">-- This is also OK: starting putting a line break after do, using $</span></a>
-<a class="sourceLine" id="cb159-9" data-line-number="9">foo x <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb159-10" data-line-number="10">  quux</a>
-<a class="sourceLine" id="cb159-11" data-line-number="11">  y <span class="ot">&lt;-</span> blorg</a>
-<a class="sourceLine" id="cb159-12" data-line-number="12">  when y <span class="fu">$</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb159-13" data-line-number="13">    thing</a>
-<a class="sourceLine" id="cb159-14" data-line-number="14">    otherThing</a>
-<a class="sourceLine" id="cb159-15" data-line-number="15">  return <span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb159"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb159-1" title="1"><span class="co">-- This is OK</span></a>
+<a class="sourceLine" id="cb159-2" title="2">foo x <span class="fu">=</span> <span class="kw">do</span> quux</a>
+<a class="sourceLine" id="cb159-3" title="3">           y <span class="ot">&lt;-</span> blorg</a>
+<a class="sourceLine" id="cb159-4" title="4">           when y (<span class="kw">do</span> thing</a>
+<a class="sourceLine" id="cb159-5" title="5">                      otherThing)</a>
+<a class="sourceLine" id="cb159-6" title="6">           <span class="fu">return</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb159-7" title="7"></a>
+<a class="sourceLine" id="cb159-8" title="8"><span class="co">-- This is also OK: starting putting a line break after do, using $</span></a>
+<a class="sourceLine" id="cb159-9" title="9">foo x <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb159-10" title="10">  quux</a>
+<a class="sourceLine" id="cb159-11" title="11">  y <span class="ot">&lt;-</span> blorg</a>
+<a class="sourceLine" id="cb159-12" title="12">  when y <span class="fu">$</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb159-13" title="13">    thing</a>
+<a class="sourceLine" id="cb159-14" title="14">    otherThing</a>
+<a class="sourceLine" id="cb159-15" title="15">  <span class="fu">return</span> <span class="dv">3</span></a></code></pre></div>
 <h2 id="lets-write-a-program"><span class="header-section-number">11.7</span> Let’s Write a Program</h2>
 <p>After all these short one-off examples, let’s turn to something a bit longer. Let’s write a program to fetch all type annotations from all <code>.hs</code> files. We use IO operations like <code>readFile</code> and <code>listDirectory</code> to read and find files, but also pure code like <code>map</code> and <code>filter</code> to do the actual processing. First off, here’s a recap of the library operations we’re using:</p>
-<div class="sourceCode" id="cb160"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb160-1" data-line-number="1"><span class="co">-- split string into lines</span></a>
-<a class="sourceLine" id="cb160-2" data-line-number="2">lines<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb160-3" data-line-number="3"><span class="co">-- `isSuffixOf suf list` is true if list ends in suf</span></a>
-<a class="sourceLine" id="cb160-4" data-line-number="4">Data.List.isSuffixOf<span class="ot"> ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb160-5" data-line-number="5"><span class="co">-- `isInfixOf inf list` is true if inf occurs inside list</span></a>
-<a class="sourceLine" id="cb160-6" data-line-number="6">Data.List.isInfixOf<span class="ot"> ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb160-7" data-line-number="7"><span class="co">-- FilePath is just an alias for String</span></a>
-<a class="sourceLine" id="cb160-8" data-line-number="8"><span class="kw">type</span> FilePath <span class="fu">=</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb160-9" data-line-number="9"><span class="co">-- get entire contents of file</span></a>
-<a class="sourceLine" id="cb160-10" data-line-number="10">readFile<span class="ot"> ::</span> FilePath <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb160-11" data-line-number="11"><span class="co">-- list files in directory</span></a>
-<a class="sourceLine" id="cb160-12" data-line-number="12">System.Directory.listDirectory<span class="ot"> ::</span> FilePath <span class="ot">-&gt;</span> <span class="dt">IO</span> [FilePath]</a>
-<a class="sourceLine" id="cb160-13" data-line-number="13"><span class="co">-- is the given file a directory?</span></a>
-<a class="sourceLine" id="cb160-14" data-line-number="14">System.Directory.doesDirectoryExist<span class="ot"> ::</span> FilePath <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a></code></pre></div>
+<div class="sourceCode" id="cb160"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb160-1" title="1"><span class="co">-- split string into lines</span></a>
+<a class="sourceLine" id="cb160-2" title="2"><span class="fu">lines</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb160-3" title="3"><span class="co">-- `isSuffixOf suf list` is true if list ends in suf</span></a>
+<a class="sourceLine" id="cb160-4" title="4">Data.List.isSuffixOf<span class="ot"> ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb160-5" title="5"><span class="co">-- `isInfixOf inf list` is true if inf occurs inside list</span></a>
+<a class="sourceLine" id="cb160-6" title="6">Data.List.isInfixOf<span class="ot"> ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb160-7" title="7"><span class="co">-- FilePath is just an alias for String</span></a>
+<a class="sourceLine" id="cb160-8" title="8"><span class="kw">type</span> <span class="dt">FilePath</span> <span class="fu">=</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb160-9" title="9"><span class="co">-- get entire contents of file</span></a>
+<a class="sourceLine" id="cb160-10" title="10"><span class="fu">readFile</span><span class="ot"> ::</span> <span class="dt">FilePath</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb160-11" title="11"><span class="co">-- list files in directory</span></a>
+<a class="sourceLine" id="cb160-12" title="12">System.Directory.listDirectory<span class="ot"> ::</span> <span class="dt">FilePath</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">FilePath</span>]</a>
+<a class="sourceLine" id="cb160-13" title="13"><span class="co">-- is the given file a directory?</span></a>
+<a class="sourceLine" id="cb160-14" title="14">System.Directory.doesDirectoryExist<span class="ot"> ::</span> <span class="dt">FilePath</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a></code></pre></div>
 <p>And here’s the program itself. You can also find it in the course repository as <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/ReadTypes.hs"><code>exercises/Examples/ReadTypes.hs</code></a>.</p>
-<div class="sourceCode" id="cb161"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb161-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Examples.ReadTypes</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb161-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb161-3" data-line-number="3"><span class="kw">import</span> <span class="dt">Control.Monad</span> (forM)</a>
-<a class="sourceLine" id="cb161-4" data-line-number="4"><span class="kw">import</span> <span class="dt">Data.List</span> (isInfixOf, isSuffixOf)</a>
-<a class="sourceLine" id="cb161-5" data-line-number="5"><span class="kw">import</span> <span class="dt">System.Directory</span> (listDirectory, doesDirectoryExist)</a>
-<a class="sourceLine" id="cb161-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb161-7" data-line-number="7"><span class="co">-- a line is a type signature if it contains :: but does not contain =</span></a>
-<a class="sourceLine" id="cb161-8" data-line-number="8"><span class="ot">isTypeSignature ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb161-9" data-line-number="9">isTypeSignature s <span class="fu">=</span> not (isInfixOf <span class="st">&quot;=&quot;</span> s) <span class="fu">&amp;&amp;</span> isInfixOf <span class="st">&quot;::&quot;</span> s</a>
-<a class="sourceLine" id="cb161-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb161-11" data-line-number="11"><span class="co">-- return list of types for a .hs file</span></a>
-<a class="sourceLine" id="cb161-12" data-line-number="12"><span class="ot">readTypesFile ::</span> FilePath <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb161-13" data-line-number="13">readTypesFile file</a>
-<a class="sourceLine" id="cb161-14" data-line-number="14">  <span class="fu">|</span> isSuffixOf <span class="st">&quot;.hs&quot;</span> file <span class="fu">=</span> <span class="kw">do</span> content <span class="ot">&lt;-</span> readFile file</a>
-<a class="sourceLine" id="cb161-15" data-line-number="15">                               <span class="kw">let</span> ls <span class="fu">=</span> lines content</a>
-<a class="sourceLine" id="cb161-16" data-line-number="16">                               return (filter isTypeSignature ls)</a>
-<a class="sourceLine" id="cb161-17" data-line-number="17">  <span class="fu">|</span> otherwise             <span class="fu">=</span> return []</a>
-<a class="sourceLine" id="cb161-18" data-line-number="18"></a>
-<a class="sourceLine" id="cb161-19" data-line-number="19"><span class="co">-- list children of directory, prepend directory name</span></a>
-<a class="sourceLine" id="cb161-20" data-line-number="20"><span class="ot">qualifiedChildren ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb161-21" data-line-number="21">qualifiedChildren path <span class="fu">=</span> <span class="kw">do</span> childs <span class="ot">&lt;-</span> listDirectory path</a>
-<a class="sourceLine" id="cb161-22" data-line-number="22">                            return (map (\name <span class="ot">-&gt;</span> path<span class="fu">++</span><span class="st">&quot;/&quot;</span><span class="fu">++</span>name) childs)</a>
-<a class="sourceLine" id="cb161-23" data-line-number="23"></a>
-<a class="sourceLine" id="cb161-24" data-line-number="24"><span class="co">-- get type signatures for all entries in given directory</span></a>
-<a class="sourceLine" id="cb161-25" data-line-number="25"><span class="co">-- note mutual recursion with readTypes</span></a>
-<a class="sourceLine" id="cb161-26" data-line-number="26"><span class="ot">readTypesDir ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb161-27" data-line-number="27">readTypesDir path <span class="fu">=</span> <span class="kw">do</span> childs <span class="ot">&lt;-</span> qualifiedChildren path</a>
-<a class="sourceLine" id="cb161-28" data-line-number="28">                       typess <span class="ot">&lt;-</span> forM childs readTypes</a>
-<a class="sourceLine" id="cb161-29" data-line-number="29">                       return (concat typess)</a>
-<a class="sourceLine" id="cb161-30" data-line-number="30"></a>
-<a class="sourceLine" id="cb161-31" data-line-number="31"><span class="co">-- recursively read types contained in a file or directory</span></a>
-<a class="sourceLine" id="cb161-32" data-line-number="32"><span class="co">-- note mutual recursion with readTypesDir</span></a>
-<a class="sourceLine" id="cb161-33" data-line-number="33"><span class="ot">readTypes ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb161-34" data-line-number="34">readTypes path <span class="fu">=</span> <span class="kw">do</span> isDir <span class="ot">&lt;-</span> doesDirectoryExist path</a>
-<a class="sourceLine" id="cb161-35" data-line-number="35">                    <span class="kw">if</span> isDir <span class="kw">then</span> readTypesDir path <span class="kw">else</span> readTypesFile path</a>
-<a class="sourceLine" id="cb161-36" data-line-number="36"></a>
-<a class="sourceLine" id="cb161-37" data-line-number="37"><span class="co">-- main is the IO action that gets run when you run the program</span></a>
-<a class="sourceLine" id="cb161-38" data-line-number="38"><span class="ot">main ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb161-39" data-line-number="39">main <span class="fu">=</span> <span class="kw">do</span> ts <span class="ot">&lt;-</span> readTypes <span class="st">&quot;.&quot;</span></a>
-<a class="sourceLine" id="cb161-40" data-line-number="40">          mapM_ putStrLn ts</a></code></pre></div>
+<div class="sourceCode" id="cb161"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb161-1" title="1"><span class="kw">module</span> <span class="dt">Examples.ReadTypes</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb161-2" title="2"></a>
+<a class="sourceLine" id="cb161-3" title="3"><span class="kw">import</span> <span class="dt">Control.Monad</span> (forM)</a>
+<a class="sourceLine" id="cb161-4" title="4"><span class="kw">import</span> <span class="dt">Data.List</span> (isInfixOf, isSuffixOf)</a>
+<a class="sourceLine" id="cb161-5" title="5"><span class="kw">import</span> <span class="dt">System.Directory</span> (listDirectory, doesDirectoryExist)</a>
+<a class="sourceLine" id="cb161-6" title="6"></a>
+<a class="sourceLine" id="cb161-7" title="7"><span class="co">-- a line is a type signature if it contains :: but does not contain =</span></a>
+<a class="sourceLine" id="cb161-8" title="8"><span class="ot">isTypeSignature ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb161-9" title="9">isTypeSignature s <span class="fu">=</span> <span class="fu">not</span> (isInfixOf <span class="st">&quot;=&quot;</span> s) <span class="fu">&amp;&amp;</span> isInfixOf <span class="st">&quot;::&quot;</span> s</a>
+<a class="sourceLine" id="cb161-10" title="10"></a>
+<a class="sourceLine" id="cb161-11" title="11"><span class="co">-- return list of types for a .hs file</span></a>
+<a class="sourceLine" id="cb161-12" title="12"><span class="ot">readTypesFile ::</span> <span class="dt">FilePath</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb161-13" title="13">readTypesFile file</a>
+<a class="sourceLine" id="cb161-14" title="14">  <span class="fu">|</span> isSuffixOf <span class="st">&quot;.hs&quot;</span> file <span class="fu">=</span> <span class="kw">do</span> content <span class="ot">&lt;-</span> <span class="fu">readFile</span> file</a>
+<a class="sourceLine" id="cb161-15" title="15">                               <span class="kw">let</span> ls <span class="fu">=</span> <span class="fu">lines</span> content</a>
+<a class="sourceLine" id="cb161-16" title="16">                               <span class="fu">return</span> (<span class="fu">filter</span> isTypeSignature ls)</a>
+<a class="sourceLine" id="cb161-17" title="17">  <span class="fu">|</span> <span class="fu">otherwise</span>             <span class="fu">=</span> <span class="fu">return</span> []</a>
+<a class="sourceLine" id="cb161-18" title="18"></a>
+<a class="sourceLine" id="cb161-19" title="19"><span class="co">-- list children of directory, prepend directory name</span></a>
+<a class="sourceLine" id="cb161-20" title="20"><span class="ot">qualifiedChildren ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb161-21" title="21">qualifiedChildren path <span class="fu">=</span> <span class="kw">do</span> childs <span class="ot">&lt;-</span> listDirectory path</a>
+<a class="sourceLine" id="cb161-22" title="22">                            <span class="fu">return</span> (<span class="fu">map</span> (\name <span class="ot">-&gt;</span> path<span class="fu">++</span><span class="st">&quot;/&quot;</span><span class="fu">++</span>name) childs)</a>
+<a class="sourceLine" id="cb161-23" title="23"></a>
+<a class="sourceLine" id="cb161-24" title="24"><span class="co">-- get type signatures for all entries in given directory</span></a>
+<a class="sourceLine" id="cb161-25" title="25"><span class="co">-- note mutual recursion with readTypes</span></a>
+<a class="sourceLine" id="cb161-26" title="26"><span class="ot">readTypesDir ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb161-27" title="27">readTypesDir path <span class="fu">=</span> <span class="kw">do</span> childs <span class="ot">&lt;-</span> qualifiedChildren path</a>
+<a class="sourceLine" id="cb161-28" title="28">                       typess <span class="ot">&lt;-</span> forM childs readTypes</a>
+<a class="sourceLine" id="cb161-29" title="29">                       <span class="fu">return</span> (<span class="fu">concat</span> typess)</a>
+<a class="sourceLine" id="cb161-30" title="30"></a>
+<a class="sourceLine" id="cb161-31" title="31"><span class="co">-- recursively read types contained in a file or directory</span></a>
+<a class="sourceLine" id="cb161-32" title="32"><span class="co">-- note mutual recursion with readTypesDir</span></a>
+<a class="sourceLine" id="cb161-33" title="33"><span class="ot">readTypes ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb161-34" title="34">readTypes path <span class="fu">=</span> <span class="kw">do</span> isDir <span class="ot">&lt;-</span> doesDirectoryExist path</a>
+<a class="sourceLine" id="cb161-35" title="35">                    <span class="kw">if</span> isDir <span class="kw">then</span> readTypesDir path <span class="kw">else</span> readTypesFile path</a>
+<a class="sourceLine" id="cb161-36" title="36"></a>
+<a class="sourceLine" id="cb161-37" title="37"><span class="co">-- main is the IO action that gets run when you run the program</span></a>
+<a class="sourceLine" id="cb161-38" title="38"><span class="ot">main ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb161-39" title="39">main <span class="fu">=</span> <span class="kw">do</span> ts <span class="ot">&lt;-</span> readTypes <span class="st">&quot;.&quot;</span></a>
+<a class="sourceLine" id="cb161-40" title="40">          <span class="fu">mapM_</span> <span class="fu">putStrLn</span> ts</a></code></pre></div>
 <p>We can run this program by going to the directory <code>exercises/Examples</code> and running:</p>
-<div class="sourceCode" id="cb162"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb162-1" data-line-number="1"><span class="fu">$</span> stack runhaskell ReadTypes.hs</a>
-<a class="sourceLine" id="cb162-2" data-line-number="2"><span class="ot">deposit ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
-<a class="sourceLine" id="cb162-3" data-line-number="3"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (<span class="dt">Int</span>,<span class="dt">Bank</span>)</a>
-<a class="sourceLine" id="cb162-4" data-line-number="4"><span class="ot">runBankOp ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>)</a>
-<a class="sourceLine" id="cb162-5" data-line-number="5"><span class="fu">...</span> and so on</a></code></pre></div>
+<div class="sourceCode" id="cb162"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb162-1" title="1"><span class="fu">$</span> stack runhaskell ReadTypes.hs</a>
+<a class="sourceLine" id="cb162-2" title="2"><span class="ot">deposit ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
+<a class="sourceLine" id="cb162-3" title="3"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (<span class="dt">Int</span>,<span class="dt">Bank</span>)</a>
+<a class="sourceLine" id="cb162-4" title="4"><span class="ot">runBankOp ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>)</a>
+<a class="sourceLine" id="cb162-5" title="5"><span class="fu">...</span> <span class="fu">and</span> so on</a></code></pre></div>
 <p>The exact output will vary according to the contents of the directory, of course.</p>
 <h2 id="what-does-it-all-mean"><span class="header-section-number">11.8</span> What Does It All Mean?</h2>
 <p>Let’s return to the functional world. How can we reconcile IO operations with Haskell being a <em>pure</em> and <em>lazy</em> language? Something like <code>putStrLn :: String -&gt; IO ()</code> is a <em>pure</em> function that returns an operation. How is it pure? <code>putStrLn x</code> is the same when <code>x</code> is the same. In other words: an operation is a <em>pure description</em> of a chain of side effects. Only <em>executing</em> the operation causes those side effects. When a Haskell program is run, only one operation is executed - it’s called <code>main :: IO ()</code>. Other operations can be run only by linking them up to <code>main</code>.</p>
 <p>When in GHCi, if an expression you type in evaluates to an operation, GHCi runs that operation for you. Here’s a demonstration of the purity of <code>print</code>:</p>
-<div class="sourceCode" id="cb163"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb163-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> x <span class="fu">=</span> print <span class="dv">1</span>   <span class="co">-- creates operation, doesn&#39;t run it</span></a>
-<a class="sourceLine" id="cb163-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> x                 <span class="co">-- runs the operation</span></a>
-<a class="sourceLine" id="cb163-3" data-line-number="3"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb163-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> x                 <span class="co">-- runs it again!</span></a>
-<a class="sourceLine" id="cb163-5" data-line-number="5"><span class="dv">1</span></a></code></pre></div>
+<div class="sourceCode" id="cb163"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb163-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> x <span class="fu">=</span> <span class="fu">print</span> <span class="dv">1</span>   <span class="co">-- creates operation, doesn&#39;t run it</span></a>
+<a class="sourceLine" id="cb163-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> x                 <span class="co">-- runs the operation</span></a>
+<a class="sourceLine" id="cb163-3" title="3"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb163-4" title="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> x                 <span class="co">-- runs it again!</span></a>
+<a class="sourceLine" id="cb163-5" title="5"><span class="dv">1</span></a></code></pre></div>
 <p><em>Operations are values</em> just like numbers, lists and functions. We can write code that operates on operations. This function takes two operations, <code>a</code> and <code>b</code>, and returns an operation that asks the user which one he’d like to run.</p>
-<div class="sourceCode" id="cb164"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb164-1" data-line-number="1"><span class="ot">choice ::</span> <span class="dt">IO</span> x <span class="ot">-&gt;</span> <span class="dt">IO</span> x <span class="ot">-&gt;</span> <span class="dt">IO</span> x</a>
-<a class="sourceLine" id="cb164-2" data-line-number="2">choice a b <span class="fu">=</span></a>
-<a class="sourceLine" id="cb164-3" data-line-number="3">  <span class="kw">do</span> putStr <span class="st">&quot;a or b? &quot;</span></a>
-<a class="sourceLine" id="cb164-4" data-line-number="4">     x <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb164-5" data-line-number="5">     <span class="kw">case</span> x <span class="kw">of</span> <span class="st">&quot;a&quot;</span> <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb164-6" data-line-number="6">               <span class="st">&quot;b&quot;</span> <span class="ot">-&gt;</span> b</a>
-<a class="sourceLine" id="cb164-7" data-line-number="7">               _ <span class="ot">-&gt;</span> <span class="kw">do</span> putStrLn <span class="st">&quot;Wrong!&quot;</span></a>
-<a class="sourceLine" id="cb164-8" data-line-number="8">                       choice a b</a></code></pre></div>
-<div class="sourceCode" id="cb165"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb165-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> choice (putStrLn <span class="st">&quot;A!!!!&quot;</span>) (putStrLn <span class="st">&quot;B!!!!&quot;</span>)</a>
-<a class="sourceLine" id="cb165-2" data-line-number="2">a or b<span class="fu">?</span> z</a>
-<a class="sourceLine" id="cb165-3" data-line-number="3"><span class="dt">Wrong</span><span class="fu">!</span></a>
-<a class="sourceLine" id="cb165-4" data-line-number="4">a or b<span class="fu">?</span> a</a>
-<a class="sourceLine" id="cb165-5" data-line-number="5"><span class="dt">A</span><span class="fu">!!!!</span></a></code></pre></div>
+<div class="sourceCode" id="cb164"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb164-1" title="1"><span class="ot">choice ::</span> <span class="dt">IO</span> x <span class="ot">-&gt;</span> <span class="dt">IO</span> x <span class="ot">-&gt;</span> <span class="dt">IO</span> x</a>
+<a class="sourceLine" id="cb164-2" title="2">choice a b <span class="fu">=</span></a>
+<a class="sourceLine" id="cb164-3" title="3">  <span class="kw">do</span> <span class="fu">putStr</span> <span class="st">&quot;a or b? &quot;</span></a>
+<a class="sourceLine" id="cb164-4" title="4">     x <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb164-5" title="5">     <span class="kw">case</span> x <span class="kw">of</span> <span class="st">&quot;a&quot;</span> <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb164-6" title="6">               <span class="st">&quot;b&quot;</span> <span class="ot">-&gt;</span> b</a>
+<a class="sourceLine" id="cb164-7" title="7">               _ <span class="ot">-&gt;</span> <span class="kw">do</span> <span class="fu">putStrLn</span> <span class="st">&quot;Wrong!&quot;</span></a>
+<a class="sourceLine" id="cb164-8" title="8">                       choice a b</a></code></pre></div>
+<div class="sourceCode" id="cb165"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb165-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> choice (<span class="fu">putStrLn</span> <span class="st">&quot;A!!!!&quot;</span>) (<span class="fu">putStrLn</span> <span class="st">&quot;B!!!!&quot;</span>)</a>
+<a class="sourceLine" id="cb165-2" title="2">a <span class="fu">or</span> b<span class="fu">?</span> z</a>
+<a class="sourceLine" id="cb165-3" title="3"><span class="dt">Wrong</span><span class="fu">!</span></a>
+<a class="sourceLine" id="cb165-4" title="4">a <span class="fu">or</span> b<span class="fu">?</span> a</a>
+<a class="sourceLine" id="cb165-5" title="5"><span class="dt">A</span><span class="fu">!!!!</span></a></code></pre></div>
 <p>Using operations specified as parameters lets us write functions like <code>mapM_</code>, which we met earlier. The implementation is a recursive IO operation that takes another IO operation as a parameter. Conceptually complicated, but simple when you read the code:</p>
-<div class="sourceCode" id="cb166"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb166-1" data-line-number="1">mapM_<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb166-2" data-line-number="2">mapM_ op     [] <span class="fu">=</span> return ()       <span class="co">-- do nothing for an empty list</span></a>
-<a class="sourceLine" id="cb166-3" data-line-number="3">mapM_ op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> op x         <span class="co">-- run operation on first element</span></a>
-<a class="sourceLine" id="cb166-4" data-line-number="4">                     mapM_ op xs  <span class="co">-- run operation on rest of list, recursively</span></a></code></pre></div>
-<div class="sourceCode" id="cb167"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb167-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> mapM_ print [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb167-2" data-line-number="2"><span class="dv">1</span></a>
-<a class="sourceLine" id="cb167-3" data-line-number="3"><span class="dv">2</span></a>
-<a class="sourceLine" id="cb167-4" data-line-number="4"><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb166"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb166-1" title="1"><span class="fu">mapM_</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb166-2" title="2"><span class="fu">mapM_</span> op     [] <span class="fu">=</span> <span class="fu">return</span> ()       <span class="co">-- do nothing for an empty list</span></a>
+<a class="sourceLine" id="cb166-3" title="3"><span class="fu">mapM_</span> op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> op x         <span class="co">-- run operation on first element</span></a>
+<a class="sourceLine" id="cb166-4" title="4">                     <span class="fu">mapM_</span> op xs  <span class="co">-- run operation on rest of list, recursively</span></a></code></pre></div>
+<div class="sourceCode" id="cb167"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb167-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">mapM_</span> <span class="fu">print</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb167-2" title="2"><span class="dv">1</span></a>
+<a class="sourceLine" id="cb167-3" title="3"><span class="dv">2</span></a>
+<a class="sourceLine" id="cb167-4" title="4"><span class="dv">3</span></a></code></pre></div>
 <h2 id="one-more-thing-ioref"><span class="header-section-number">11.9</span> One More Thing: IORef</h2>
 <p>So far the only side-effects we’ve been able to produce in IO have been terminal (<code>getLine</code>, <code>print</code>) and file (<code>readFile</code>, <code>listDirectory</code>) IO. Imperative programs written in Java, Python or C have other types of side effects too that we can’t express in pure Haskell. One of these is <em>mutable (i.e. changeable) state</em>. A pure function can not read mutable state, because otherwise two invocations of the same function might not return the same value.</p>
 <p>The Haskell type <code>IORef a</code> from the module <code>Data.IORef</code> is a mutable reference to a value of type <code>a</code></p>
-<div class="sourceCode" id="cb168"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb168-1" data-line-number="1"><span class="ot">newIORef ::</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> (<span class="dt">IORef</span> a)                <span class="co">-- create a new IORef containing a value</span></a>
-<a class="sourceLine" id="cb168-2" data-line-number="2"><span class="ot">readIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> a                 <span class="co">-- produce value contained in IORef</span></a>
-<a class="sourceLine" id="cb168-3" data-line-number="3"><span class="ot">writeIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()          <span class="co">-- set value in IORef</span></a>
-<a class="sourceLine" id="cb168-4" data-line-number="4"><span class="ot">modifyIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()  <span class="co">-- modify value contained in IORef with a pure function</span></a></code></pre></div>
+<div class="sourceCode" id="cb168"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb168-1" title="1"><span class="ot">newIORef ::</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> (<span class="dt">IORef</span> a)                <span class="co">-- create a new IORef containing a value</span></a>
+<a class="sourceLine" id="cb168-2" title="2"><span class="ot">readIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> a                 <span class="co">-- produce value contained in IORef</span></a>
+<a class="sourceLine" id="cb168-3" title="3"><span class="ot">writeIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()          <span class="co">-- set value in IORef</span></a>
+<a class="sourceLine" id="cb168-4" title="4"><span class="ot">modifyIORef ::</span> <span class="dt">IORef</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()  <span class="co">-- modify value contained in IORef with a pure function</span></a></code></pre></div>
 <p>Here are some examples of using an IORef in GHCi:</p>
-<div class="sourceCode" id="cb169"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb169-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>m <span class="fu">+</span><span class="dt">Data.IORef</span></a>
-<a class="sourceLine" id="cb169-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> myRef <span class="ot">&lt;-</span> newIORef <span class="st">&quot;banana&quot;</span></a>
-<a class="sourceLine" id="cb169-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
-<a class="sourceLine" id="cb169-4" data-line-number="4"><span class="st">&quot;banana&quot;</span></a>
-<a class="sourceLine" id="cb169-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> writeIORef myRef <span class="st">&quot;apple&quot;</span></a>
-<a class="sourceLine" id="cb169-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
-<a class="sourceLine" id="cb169-7" data-line-number="7"><span class="st">&quot;apple&quot;</span></a>
-<a class="sourceLine" id="cb169-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> modifyIORef myRef reverse</a>
-<a class="sourceLine" id="cb169-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
-<a class="sourceLine" id="cb169-10" data-line-number="10"><span class="st">&quot;elppa&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb169"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb169-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>m <span class="fu">+</span><span class="dt">Data.IORef</span></a>
+<a class="sourceLine" id="cb169-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> myRef <span class="ot">&lt;-</span> newIORef <span class="st">&quot;banana&quot;</span></a>
+<a class="sourceLine" id="cb169-3" title="3"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
+<a class="sourceLine" id="cb169-4" title="4"><span class="st">&quot;banana&quot;</span></a>
+<a class="sourceLine" id="cb169-5" title="5"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> writeIORef myRef <span class="st">&quot;apple&quot;</span></a>
+<a class="sourceLine" id="cb169-6" title="6"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
+<a class="sourceLine" id="cb169-7" title="7"><span class="st">&quot;apple&quot;</span></a>
+<a class="sourceLine" id="cb169-8" title="8"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> modifyIORef myRef <span class="fu">reverse</span></a>
+<a class="sourceLine" id="cb169-9" title="9"><span class="dt">Prelude</span> <span class="dt">Data.IORef</span><span class="fu">&gt;</span> readIORef myRef</a>
+<a class="sourceLine" id="cb169-10" title="10"><span class="st">&quot;elppa&quot;</span></a></code></pre></div>
 <p>Here’s an example of using an <code>IORef</code> to sum the values in a list. Note the similarity with an imperative loop.</p>
-<div class="sourceCode" id="cb170"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb170-1" data-line-number="1"><span class="ot">sumList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb170-2" data-line-number="2">sumList xs <span class="fu">=</span> <span class="kw">do</span> r <span class="ot">&lt;-</span> newIORef <span class="dv">0</span>                       <span class="co">-- initialize r to 0</span></a>
-<a class="sourceLine" id="cb170-3" data-line-number="3">                forM_ xs (\x <span class="ot">-&gt;</span> modifyIORef r (x<span class="fu">+</span>))   <span class="co">-- for every xs, add it to r</span></a>
-<a class="sourceLine" id="cb170-4" data-line-number="4">                readIORef r                           <span class="co">-- get last value of r</span></a></code></pre></div>
+<div class="sourceCode" id="cb170"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb170-1" title="1"><span class="ot">sumList ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb170-2" title="2">sumList xs <span class="fu">=</span> <span class="kw">do</span> r <span class="ot">&lt;-</span> newIORef <span class="dv">0</span>                       <span class="co">-- initialize r to 0</span></a>
+<a class="sourceLine" id="cb170-3" title="3">                forM_ xs (\x <span class="ot">-&gt;</span> modifyIORef r (x<span class="fu">+</span>))   <span class="co">-- for every xs, add it to r</span></a>
+<a class="sourceLine" id="cb170-4" title="4">                readIORef r                           <span class="co">-- get last value of r</span></a></code></pre></div>
 <p>Using <code>IORef</code> isn’t necessary most of the time. Haskell style prefers recursion, arguments and return values. However real world programs might need one or two IORefs occasionally.</p>
 <h2 id="summary-of-io"><span class="header-section-number">11.10</span> Summary of IO</h2>
 <p>A value of type <code>IO X</code> is an <em>IO operation</em> that <em>produces</em> a value of type X <em>when run</em>. Operations are pure values. Only <em>running</em> the operation causes the side effects.</p>
 <p>IO operations can combined together using <code>do</code>-notation:</p>
-<div class="sourceCode" id="cb171"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb171-1" data-line-number="1"><span class="ot">op ::</span> <span class="dt">X</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Y</span></a>
-<a class="sourceLine" id="cb171-2" data-line-number="2">op arg <span class="fu">=</span> <span class="kw">do</span> operation                 <span class="co">-- run operation</span></a>
-<a class="sourceLine" id="cb171-3" data-line-number="3">            operation2 arg            <span class="co">-- run operation with argument</span></a>
-<a class="sourceLine" id="cb171-4" data-line-number="4">            result <span class="ot">&lt;-</span> operation3 arg  <span class="co">-- run operation with argument, store result</span></a>
-<a class="sourceLine" id="cb171-5" data-line-number="5">            <span class="kw">let</span> something <span class="fu">=</span> f result  <span class="co">-- run a pure function f, store result</span></a>
-<a class="sourceLine" id="cb171-6" data-line-number="6">            finalOperation            <span class="co">-- last operation produces the the return value</span></a></code></pre></div>
+<div class="sourceCode" id="cb171"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb171-1" title="1"><span class="ot">op ::</span> <span class="dt">X</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Y</span></a>
+<a class="sourceLine" id="cb171-2" title="2">op arg <span class="fu">=</span> <span class="kw">do</span> operation                 <span class="co">-- run operation</span></a>
+<a class="sourceLine" id="cb171-3" title="3">            operation2 arg            <span class="co">-- run operation with argument</span></a>
+<a class="sourceLine" id="cb171-4" title="4">            result <span class="ot">&lt;-</span> operation3 arg  <span class="co">-- run operation with argument, store result</span></a>
+<a class="sourceLine" id="cb171-5" title="5">            <span class="kw">let</span> something <span class="fu">=</span> f result  <span class="co">-- run a pure function f, store result</span></a>
+<a class="sourceLine" id="cb171-6" title="6">            finalOperation            <span class="co">-- last operation produces the the return value</span></a></code></pre></div>
 <p>The <code>return x</code> operation is an operation that always produces value <code>x</code>. When <code>x :: a</code>, <code>return x :: IO a</code>.</p>
 <p>Useful IO operations:</p>
-<div class="sourceCode" id="cb172"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb172-1" data-line-number="1"><span class="co">-- printing &amp; reading</span></a>
-<a class="sourceLine" id="cb172-2" data-line-number="2">putStr<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb172-3" data-line-number="3">putStrLn<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb172-4" data-line-number="4">print<span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb172-5" data-line-number="5">getLine<span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb172-6" data-line-number="6">readLn<span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">IO</span> a</a>
-<a class="sourceLine" id="cb172-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb172-8" data-line-number="8"><span class="co">-- control structures from Control.Monad</span></a>
-<a class="sourceLine" id="cb172-9" data-line-number="9"><span class="ot">when ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- when b op performs op if b is true</span></a>
-<a class="sourceLine" id="cb172-10" data-line-number="10"><span class="ot">unless ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="co">-- unless b op performs op if b is false</span></a>
-<a class="sourceLine" id="cb172-11" data-line-number="11"><span class="ot">replicateM ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> [a]   <span class="co">-- do something many times, collect results</span></a>
-<a class="sourceLine" id="cb172-12" data-line-number="12"><span class="ot">replicateM_ ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- do something many times, throw away the results</span></a>
-<a class="sourceLine" id="cb172-13" data-line-number="13">mapM<span class="ot"> ::</span>  (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> [b] <span class="co">-- do something for every list element</span></a>
-<a class="sourceLine" id="cb172-14" data-line-number="14">mapM_<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()  <span class="co">-- do something for every list element, throw away the results</span></a>
-<a class="sourceLine" id="cb172-15" data-line-number="15"><span class="ot">forM ::</span>  [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> [b] <span class="co">-- the same, but arguments flipped</span></a>
-<a class="sourceLine" id="cb172-16" data-line-number="16"><span class="ot">forM_ ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb172-17" data-line-number="17"></a>
-<a class="sourceLine" id="cb172-18" data-line-number="18"><span class="co">-- files</span></a>
-<a class="sourceLine" id="cb172-19" data-line-number="19">readFile<span class="ot"> ::</span> FilePath <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
+<div class="sourceCode" id="cb172"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb172-1" title="1"><span class="co">-- printing &amp; reading</span></a>
+<a class="sourceLine" id="cb172-2" title="2"><span class="fu">putStr</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb172-3" title="3"><span class="fu">putStrLn</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb172-4" title="4"><span class="fu">print</span><span class="ot"> ::</span> <span class="dt">Show</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb172-5" title="5"><span class="fu">getLine</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb172-6" title="6"><span class="fu">readLn</span><span class="ot"> ::</span> <span class="dt">Read</span> a <span class="ot">=&gt;</span> <span class="dt">IO</span> a</a>
+<a class="sourceLine" id="cb172-7" title="7"></a>
+<a class="sourceLine" id="cb172-8" title="8"><span class="co">-- control structures from Control.Monad</span></a>
+<a class="sourceLine" id="cb172-9" title="9"><span class="ot">when ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- when b op performs op if b is true</span></a>
+<a class="sourceLine" id="cb172-10" title="10"><span class="ot">unless ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="ot">-&gt;</span> <span class="dt">IO</span> () <span class="co">-- unless b op performs op if b is false</span></a>
+<a class="sourceLine" id="cb172-11" title="11"><span class="ot">replicateM ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> [a]   <span class="co">-- do something many times, collect results</span></a>
+<a class="sourceLine" id="cb172-12" title="12"><span class="ot">replicateM_ ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()   <span class="co">-- do something many times, throw away the results</span></a>
+<a class="sourceLine" id="cb172-13" title="13"><span class="fu">mapM</span><span class="ot"> ::</span>  (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> [b] <span class="co">-- do something for every list element</span></a>
+<a class="sourceLine" id="cb172-14" title="14"><span class="fu">mapM_</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">IO</span> ()  <span class="co">-- do something for every list element, throw away the results</span></a>
+<a class="sourceLine" id="cb172-15" title="15"><span class="ot">forM ::</span>  [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> [b] <span class="co">-- the same, but arguments flipped</span></a>
+<a class="sourceLine" id="cb172-16" title="16"><span class="ot">forM_ ::</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">IO</span> b) <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb172-17" title="17"></a>
+<a class="sourceLine" id="cb172-18" title="18"><span class="co">-- files</span></a>
+<a class="sourceLine" id="cb172-19" title="19"><span class="fu">readFile</span><span class="ot"> ::</span> <span class="dt">FilePath</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a></code></pre></div>
 <h2 id="quiz-2"><span class="header-section-number">11.11</span> Quiz</h2>
 <p>What is the type of this IO operation?</p>
-<div class="sourceCode" id="cb173"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb173-1" data-line-number="1">foo x <span class="fu">=</span> <span class="kw">do</span> putStrLn x</a>
-<a class="sourceLine" id="cb173-2" data-line-number="2">           y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb173-3" data-line-number="3">           return (length y)</a></code></pre></div>
+<div class="sourceCode" id="cb173"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb173-1" title="1">foo x <span class="fu">=</span> <span class="kw">do</span> <span class="fu">putStrLn</span> x</a>
+<a class="sourceLine" id="cb173-2" title="2">           y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb173-3" title="3">           <span class="fu">return</span> (<span class="fu">length</span> y)</a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>String -&gt; IO String</code>
@@ -2117,11 +2115,11 @@ Prelude&gt; final
 </li>
 </ol>
 <p>Which of these lines could be used in place of <code>????</code></p>
-<div class="sourceCode" id="cb174"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb174-1" data-line-number="1"><span class="ot">quux ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb174-2" data-line-number="2">quux q <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb174-3" data-line-number="3">            z <span class="ot">&lt;-</span> getLine</a>
-<a class="sourceLine" id="cb174-4" data-line-number="4">            putStrLn (y<span class="fu">++</span>z)</a>
-<a class="sourceLine" id="cb174-5" data-line-number="5">            <span class="fu">????</span></a></code></pre></div>
+<div class="sourceCode" id="cb174"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb174-1" title="1"><span class="ot">quux ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb174-2" title="2">quux q <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb174-3" title="3">            z <span class="ot">&lt;-</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb174-4" title="4">            <span class="fu">putStrLn</span> (y<span class="fu">++</span>z)</a>
+<a class="sourceLine" id="cb174-5" title="5">            <span class="fu">????</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>q &lt;- getLine</code>
@@ -2137,10 +2135,10 @@ Prelude&gt; final
 </li>
 </ol>
 <p>What values does <code>blorg [1,2,3]</code> print? That is, what values <code>x</code> does it call <code>print x</code> for. The value produced by <code>blorg</code> doesn’t count.</p>
-<div class="sourceCode" id="cb175"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb175-1" data-line-number="1">blorg [] <span class="fu">=</span> return <span class="dv">0</span></a>
-<a class="sourceLine" id="cb175-2" data-line-number="2">blorg (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> m <span class="ot">&lt;-</span> blorg xs</a>
-<a class="sourceLine" id="cb175-3" data-line-number="3">                  print x</a>
-<a class="sourceLine" id="cb175-4" data-line-number="4">                  return (m<span class="fu">+</span>x)</a></code></pre></div>
+<div class="sourceCode" id="cb175"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb175-1" title="1">blorg [] <span class="fu">=</span> <span class="fu">return</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb175-2" title="2">blorg (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> m <span class="ot">&lt;-</span> blorg xs</a>
+<a class="sourceLine" id="cb175-3" title="3">                  <span class="fu">print</span> x</a>
+<a class="sourceLine" id="cb175-4" title="4">                  <span class="fu">return</span> (m<span class="fu">+</span>x)</a></code></pre></div>
 <ol class="quiz">
 <li>
 It prints <code>1</code>, <code>2</code>, <code>3</code>
@@ -2199,37 +2197,37 @@ Query the user for a number and return it.
 <h2 id="functors"><span class="header-section-number">12.2</span> Functors</h2>
 <h3 id="preserving-structure"><span class="header-section-number">12.2.1</span> Preserving Structure</h3>
 <p>Remember the <code>map</code> function for lists? Here’s the definition again:</p>
-<div class="sourceCode" id="cb176"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb176-1" data-line-number="1">map<span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb176-2" data-line-number="2">map _ []     <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb176-3" data-line-number="3">map g (x<span class="fu">:</span>xs) <span class="fu">=</span> g x <span class="fu">:</span> map g xs</a></code></pre></div>
+<div class="sourceCode" id="cb176"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb176-1" title="1"><span class="fu">map</span><span class="ot"> ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb176-2" title="2"><span class="fu">map</span> _ []     <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb176-3" title="3"><span class="fu">map</span> g (x<span class="fu">:</span>xs) <span class="fu">=</span> g x <span class="fu">:</span> <span class="fu">map</span> g xs</a></code></pre></div>
 <p>It applies a function <code>g :: a -&gt; b</code> to each element of a list of type <code>[a]</code>, returning a list of type <code>[b]</code>. Another way to express the type of <code>map</code> would be <code>(a -&gt; b) -&gt; ([a] -&gt; [b])</code>. This is the same type because <code>-&gt;</code> associates to right. The extra parentheses emphasize the fact that <code>map</code> converts the function <code>g :: a -&gt; b</code> into a function <code>map g :: [a] -&gt; [b]</code>. This means that <code>map</code> is a <em>higher-order function</em> that transforms functions to functions.</p>
 <p>As <code>map</code> is parametrically polymorphic, its definition doesn’t depend on the type of values stored in the list. Thus, every function of type <code>a -&gt; b</code> is converted into a function of type <code>[a] -&gt; [b]</code> using exactly the same logic. Using the definition above, we can see that:</p>
-<div class="sourceCode" id="cb177"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb177-1" data-line-number="1">map (<span class="fu">||</span> <span class="dt">True</span>) [<span class="dt">True</span>, <span class="dt">True</span>, <span class="dt">False</span>]</a>
-<a class="sourceLine" id="cb177-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dt">True</span> <span class="fu">||</span> <span class="dt">True</span>, <span class="dt">True</span> <span class="fu">||</span> <span class="dt">True</span>, <span class="dt">False</span> <span class="fu">||</span> <span class="dt">True</span>]</a>
-<a class="sourceLine" id="cb177-3" data-line-number="3">  <span class="fu">==&gt;</span> [<span class="dt">True</span>, <span class="dt">True</span>, <span class="dt">True</span>]</a>
-<a class="sourceLine" id="cb177-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb177-5" data-line-number="5">map (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb177-6" data-line-number="6">  <span class="fu">==&gt;</span> [<span class="dv">1</span> <span class="fu">+</span> <span class="dv">1</span>, <span class="dv">2</span> <span class="fu">+</span> <span class="dv">1</span>, <span class="dv">3</span> <span class="fu">+</span> <span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb177-7" data-line-number="7">  <span class="fu">==&gt;</span> [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb177-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb177-9" data-line-number="9">map (<span class="fu">++</span><span class="st">&quot;1&quot;</span>) [<span class="st">&quot;1&quot;</span>, <span class="st">&quot;2&quot;</span>, <span class="st">&quot;3&quot;</span>]</a>
-<a class="sourceLine" id="cb177-10" data-line-number="10">  <span class="fu">==&gt;</span> [<span class="st">&quot;1&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>, <span class="st">&quot;2&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>, <span class="st">&quot;3&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>]</a>
-<a class="sourceLine" id="cb177-11" data-line-number="11">  <span class="fu">==&gt;</span> [<span class="st">&quot;11&quot;</span>, <span class="st">&quot;21&quot;</span>, <span class="st">&quot;31&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb177"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb177-1" title="1"><span class="fu">map</span> (<span class="fu">||</span> <span class="dt">True</span>) [<span class="dt">True</span>, <span class="dt">True</span>, <span class="dt">False</span>]</a>
+<a class="sourceLine" id="cb177-2" title="2">  <span class="fu">==&gt;</span> [<span class="dt">True</span> <span class="fu">||</span> <span class="dt">True</span>, <span class="dt">True</span> <span class="fu">||</span> <span class="dt">True</span>, <span class="dt">False</span> <span class="fu">||</span> <span class="dt">True</span>]</a>
+<a class="sourceLine" id="cb177-3" title="3">  <span class="fu">==&gt;</span> [<span class="dt">True</span>, <span class="dt">True</span>, <span class="dt">True</span>]</a>
+<a class="sourceLine" id="cb177-4" title="4"></a>
+<a class="sourceLine" id="cb177-5" title="5"><span class="fu">map</span> (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb177-6" title="6">  <span class="fu">==&gt;</span> [<span class="dv">1</span> <span class="fu">+</span> <span class="dv">1</span>, <span class="dv">2</span> <span class="fu">+</span> <span class="dv">1</span>, <span class="dv">3</span> <span class="fu">+</span> <span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb177-7" title="7">  <span class="fu">==&gt;</span> [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb177-8" title="8"></a>
+<a class="sourceLine" id="cb177-9" title="9"><span class="fu">map</span> (<span class="fu">++</span><span class="st">&quot;1&quot;</span>) [<span class="st">&quot;1&quot;</span>, <span class="st">&quot;2&quot;</span>, <span class="st">&quot;3&quot;</span>]</a>
+<a class="sourceLine" id="cb177-10" title="10">  <span class="fu">==&gt;</span> [<span class="st">&quot;1&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>, <span class="st">&quot;2&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>, <span class="st">&quot;3&quot;</span> <span class="fu">++</span> <span class="st">&quot;1&quot;</span>]</a>
+<a class="sourceLine" id="cb177-11" title="11">  <span class="fu">==&gt;</span> [<span class="st">&quot;11&quot;</span>, <span class="st">&quot;21&quot;</span>, <span class="st">&quot;31&quot;</span>]</a></code></pre></div>
 <p>What’s notable here is that <code>map</code> <em>preserves the structure</em> of a list. The length of the list and the relative positions of the elements are the same. The general idea is demonstrated in the picture below.</p>
 <figure>
 <img src="img/map.svg" alt="Mapping a function g to a list" /><figcaption>Mapping a function <code>g</code> to a list</figcaption>
 </figure>
 <p>Let’s see if we can find other similar functions. A value of type <code>Maybe a</code> is kind of like a list of length at most 1. Let’s map over a <code>Maybe</code>! Can you see the similarity with the definition of <code>map</code>?</p>
-<div class="sourceCode" id="cb178"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb178-1" data-line-number="1"><span class="ot">mapMaybe ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb178-2" data-line-number="2">mapMaybe f <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb178-3" data-line-number="3">mapMaybe f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb178"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb178-1" title="1"><span class="ot">mapMaybe ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb178-2" title="2">mapMaybe f <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb178-3" title="3">mapMaybe f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a></code></pre></div>
 <p>Here too, the structure of the value is preserved. A <code>Nothing</code> turns into a <code>Nothing</code>, and a <code>Just</code> turns into a <code>Just</code>. Here too, we can think of the type as <code>(a -&gt; b) -&gt; (Maybe a -&gt; Maybe b)</code>, converting (or “lifting”) a normal function into a function that works on Maybes.</p>
 <p>One more example: consider binary trees.</p>
-<div class="sourceCode" id="cb179"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb179-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
-<a class="sourceLine" id="cb179-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb179-3" data-line-number="3"><span class="ot">mapTree ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Tree</span> a <span class="ot">-&gt;</span> <span class="dt">Tree</span> b</a>
-<a class="sourceLine" id="cb179-4" data-line-number="4">mapTree f <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dt">Leaf</span></a>
-<a class="sourceLine" id="cb179-5" data-line-number="5">mapTree f (<span class="dt">Node</span> val left right) <span class="fu">=</span> <span class="dt">Node</span> (f val) (mapTree f left) (mapTree f right)</a></code></pre></div>
+<div class="sourceCode" id="cb179"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb179-1" title="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
+<a class="sourceLine" id="cb179-2" title="2"></a>
+<a class="sourceLine" id="cb179-3" title="3"><span class="ot">mapTree ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Tree</span> a <span class="ot">-&gt;</span> <span class="dt">Tree</span> b</a>
+<a class="sourceLine" id="cb179-4" title="4">mapTree f <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dt">Leaf</span></a>
+<a class="sourceLine" id="cb179-5" title="5">mapTree f (<span class="dt">Node</span> val left right) <span class="fu">=</span> <span class="dt">Node</span> (f val) (mapTree f left) (mapTree f right)</a></code></pre></div>
 <p>A binary tree might look like this:</p>
 <figure>
 <img src="img/mapTreeBefore.svg" alt="A binary tree" /><figcaption>A binary tree</figcaption>
@@ -2240,45 +2238,45 @@ Query the user for a number and return it.
 </figure>
 <h3 id="the-functor-class"><span class="header-section-number">12.2.2</span> The <code>Functor</code> Class</h3>
 <p>Now we have three different structure-preserving mapping functions. Three similar operations over different types. Could we write a type class to capture this similarity?</p>
-<div class="sourceCode" id="cb180"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb180-1" data-line-number="1">map<span class="ot">      ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span>      [a] <span class="ot">-&gt;</span>      [b]</a>
-<a class="sourceLine" id="cb180-2" data-line-number="2"><span class="ot">mapMaybe ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a  <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb180-3" data-line-number="3"><span class="ot">mapTree  ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Tree</span>  a  <span class="ot">-&gt;</span> <span class="dt">Tree</span>  b</a></code></pre></div>
+<div class="sourceCode" id="cb180"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb180-1" title="1"><span class="fu">map</span><span class="ot">      ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span>      [a] <span class="ot">-&gt;</span>      [b]</a>
+<a class="sourceLine" id="cb180-2" title="2"><span class="ot">mapMaybe ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a  <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb180-3" title="3"><span class="ot">mapTree  ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Tree</span>  a  <span class="ot">-&gt;</span> <span class="dt">Tree</span>  b</a></code></pre></div>
 <p>A naive attempt at writing a type class runs into problems. If we try to abstract over <code>Maybe c</code>, it seems we can’t write the right type for the map operation. We’d need to be able to change the type parameter <code>c</code> somehow.</p>
-<div class="sourceCode" id="cb181"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb181-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Mappable</span> m <span class="kw">where</span></a>
-<a class="sourceLine" id="cb181-2" data-line-number="2"><span class="ot">  mapThing ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> m <span class="ot">-&gt;</span> m</a>
-<a class="sourceLine" id="cb181-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb181-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Mappable</span> (<span class="dt">Maybe</span> c) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb181-5" data-line-number="5"><span class="ot">  mapThing ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> c <span class="ot">-&gt;</span> <span class="dt">Maybe</span> c</a>
-<a class="sourceLine" id="cb181-6" data-line-number="6">  mapThing <span class="fu">=</span> <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb181"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb181-1" title="1"><span class="kw">class</span> <span class="dt">Mappable</span> m <span class="kw">where</span></a>
+<a class="sourceLine" id="cb181-2" title="2"><span class="ot">  mapThing ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> m <span class="ot">-&gt;</span> m</a>
+<a class="sourceLine" id="cb181-3" title="3"></a>
+<a class="sourceLine" id="cb181-4" title="4"><span class="kw">instance</span> <span class="dt">Mappable</span> (<span class="dt">Maybe</span> c) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb181-5" title="5"><span class="ot">  mapThing ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> c <span class="ot">-&gt;</span> <span class="dt">Maybe</span> c</a>
+<a class="sourceLine" id="cb181-6" title="6">  mapThing <span class="fu">=</span> <span class="fu">...</span></a></code></pre></div>
 <p>Luckily Haskell type classes have a feature we haven’t covered before. You can write classes for <em>type constructors</em> in addition to types. What does this mean? Let’s just have a look at the standard type class <code>Functor</code> that does what we tried to do with our <code>Mappable</code>.</p>
-<div class="sourceCode" id="cb182"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb182-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="kw">where</span></a>
-<a class="sourceLine" id="cb182-2" data-line-number="2"><span class="ot">  fmap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
+<div class="sourceCode" id="cb182"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb182-1" title="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="kw">where</span></a>
+<a class="sourceLine" id="cb182-2" title="2"><span class="ot">  fmap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
 <p>Note how the type parameter <code>f</code> is a type constructor: it’s being passed <code>a</code> and <code>b</code> arguments in different parts of the type of <code>fmap</code>. Now let’s see the instance for <code>Maybe</code>.</p>
-<div class="sourceCode" id="cb183"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb183-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb183-2" data-line-number="2">  <span class="co">-- In this instance, the type of fmap is:</span></a>
-<a class="sourceLine" id="cb183-3" data-line-number="3">  <span class="co">-- fmap :: (a -&gt; b) -&gt; Maybe a -&gt; Maybe b</span></a>
-<a class="sourceLine" id="cb183-4" data-line-number="4">  fmap f <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb183-5" data-line-number="5">  fmap f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb183"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb183-1" title="1"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb183-2" title="2">  <span class="co">-- In this instance, the type of fmap is:</span></a>
+<a class="sourceLine" id="cb183-3" title="3">  <span class="co">-- fmap :: (a -&gt; b) -&gt; Maybe a -&gt; Maybe b</span></a>
+<a class="sourceLine" id="cb183-4" title="4">  <span class="fu">fmap</span> f <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb183-5" title="5">  <span class="fu">fmap</span> f (<span class="dt">Just</span> x) <span class="fu">=</span> <span class="dt">Just</span> (f x)</a></code></pre></div>
 <p>Now <code>fmap</code> has the right type and we can implement it like <code>mapMaybe</code>! Note how we’ve declared <code>instance Functor Maybe</code> instead of <code>instance Functor (Maybe a)</code>. The type <code>Maybe a</code> isn’t a functor, the type constructor <code>Maybe</code> is.</p>
 <p>The type constructor for lists is written <code>[]</code>. It’s special syntax, just like other list syntax. However if the type <code>[a]</code> was written <code>List a</code>, the type constructor <code>[]</code> would mean <code>List</code>.</p>
-<div class="sourceCode" id="cb184"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb184-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Functor</span> [] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb184-2" data-line-number="2">  fmap <span class="fu">=</span> map</a></code></pre></div>
+<div class="sourceCode" id="cb184"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb184-1" title="1"><span class="kw">instance</span> <span class="dt">Functor</span> [] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb184-2" title="2">  <span class="fu">fmap</span> <span class="fu">=</span> <span class="fu">map</span></a></code></pre></div>
 <p>Here’s the final of our examples, as a <code>Functor</code> instance.</p>
-<div class="sourceCode" id="cb185"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb185-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
-<a class="sourceLine" id="cb185-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb185-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Tree</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb185-4" data-line-number="4">  fmap _ <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dt">Leaf</span></a>
-<a class="sourceLine" id="cb185-5" data-line-number="5">  fmap f (<span class="dt">Node</span> val left right) <span class="fu">=</span> <span class="dt">Node</span> (f val) (fmap f left) (fmap f right)</a></code></pre></div>
+<div class="sourceCode" id="cb185"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb185-1" title="1"><span class="kw">data</span> <span class="dt">Tree</span> a <span class="fu">=</span> <span class="dt">Leaf</span> <span class="fu">|</span> <span class="dt">Node</span> a (<span class="dt">Tree</span> a) (<span class="dt">Tree</span> a)</a>
+<a class="sourceLine" id="cb185-2" title="2"></a>
+<a class="sourceLine" id="cb185-3" title="3"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Tree</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb185-4" title="4">  <span class="fu">fmap</span> _ <span class="dt">Leaf</span> <span class="fu">=</span> <span class="dt">Leaf</span></a>
+<a class="sourceLine" id="cb185-5" title="5">  <span class="fu">fmap</span> f (<span class="dt">Node</span> val left right) <span class="fu">=</span> <span class="dt">Node</span> (f val) (<span class="fu">fmap</span> f left) (<span class="fu">fmap</span> f right)</a></code></pre></div>
 <p>Sidenote: the term functor comes originally from a branch of mathematics called <a href="https://en.wikipedia.org/wiki/Category_theory">category theory</a>. However, to work with Haskell you don’t need to know any category theory. As you progress in learning Haskell, you might get interested in category theory, and it can be a valuable source of new ideas for programming. Category theory can feel intimidating, so it’s good to know that you can get on fine without it. For now, when you see functor, you can just think “something I can map over”, or perhaps “a container”.</p>
 <p>Let’s zoom out a bit. When we have an instance <code>Functor MyFun</code> we know that we can map a type <code>X</code> into a new type <code>MyFun X</code> (since <code>MyFun</code> is a type constructor), but also that we can lift a function <code>f</code> that takes an <code>X</code> argument into a function <code>fmap f</code> that takes a <code>MyFun X</code> argument! So you could say we’re mapping both on the type level and the value level.</p>
 <p>Oh right, one more thing. Once you’ve gotten the hang of <code>fmap</code> you might find yourself using it quite a bit. For code that uses <code>fmap</code> heavily it can be nice to use its infix alias, <code>&lt;$&gt;</code>. Consider the symmetry between <code>$</code> and <code>&lt;$&gt;</code> in these examples:</p>
-<div class="sourceCode" id="cb186"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb186-1" data-line-number="1">(<span class="fu">+</span><span class="dv">1</span>) <span class="fu">&lt;$&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]    <span class="fu">==&gt;</span>  [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb186-2" data-line-number="2">not <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="dt">False</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb186-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb186-4" data-line-number="4">reverse <span class="fu">.</span> tail  <span class="fu">$</span>       <span class="st">&quot;hello&quot;</span>       <span class="fu">==&gt;</span>  <span class="st">&quot;olle&quot;</span></a>
-<a class="sourceLine" id="cb186-5" data-line-number="5">reverse <span class="fu">.</span> tail <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;hello&quot;</span>       <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;olle&quot;</span></a>
-<a class="sourceLine" id="cb186-6" data-line-number="6"><span class="co">-- which is the same as</span></a>
-<a class="sourceLine" id="cb186-7" data-line-number="7">fmap (reverse <span class="fu">.</span> tail) (<span class="dt">Just</span> <span class="st">&quot;hello&quot;</span>)  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;olle&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb186"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb186-1" title="1">(<span class="fu">+</span><span class="dv">1</span>) <span class="fu">&lt;$&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]    <span class="fu">==&gt;</span>  [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb186-2" title="2"><span class="fu">not</span> <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="dt">False</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb186-3" title="3"></a>
+<a class="sourceLine" id="cb186-4" title="4"><span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">tail</span>  <span class="fu">$</span>       <span class="st">&quot;hello&quot;</span>       <span class="fu">==&gt;</span>  <span class="st">&quot;olle&quot;</span></a>
+<a class="sourceLine" id="cb186-5" title="5"><span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">tail</span> <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;hello&quot;</span>       <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;olle&quot;</span></a>
+<a class="sourceLine" id="cb186-6" title="6"><span class="co">-- which is the same as</span></a>
+<a class="sourceLine" id="cb186-7" title="7"><span class="fu">fmap</span> (<span class="fu">reverse</span> <span class="fu">.</span> <span class="fu">tail</span>) (<span class="dt">Just</span> <span class="st">&quot;hello&quot;</span>)  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;olle&quot;</span></a></code></pre></div>
 <h2 id="lawful-instances"><span class="header-section-number">12.3</span> Lawful Instances</h2>
 <p>What is this “preserving of the structure” that was mentioned above exactly? The following two <em>functor laws</em> are expected to hold for any <code>Functor</code> instance <code>f</code> (though unfortunately Haskell compilers can’t enforce them):</p>
 <ol type="1">
@@ -2286,33 +2284,33 @@ Query the user for a number and return it.
 <li><code>fmap (f . g) === fmap f . fmap g</code></li>
 </ol>
 <p>Don’t worry if that sounded abstract! The first law says that a functor maps <code>id :: a -&gt; a</code> into <code>id :: f a -&gt; f a</code>. (<code>id</code> is the identity function, meaning that <code>id x = x</code>.) Let’s be concrete and see how it works for the list <code>[1,2,3]</code>:</p>
-<div class="sourceCode" id="cb187"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb187-1" data-line-number="1">fmap id [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> map id [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb187-2" data-line-number="2">                <span class="fu">==&gt;</span> map id (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb187-3" data-line-number="3">                <span class="fu">==&gt;</span> id <span class="dv">1</span> <span class="fu">:</span> map id [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb187-4" data-line-number="4">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> map id [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb187-5" data-line-number="5">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> id <span class="dv">2</span> <span class="fu">:</span> map id [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb187-6" data-line-number="6">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">2</span> <span class="fu">:</span> id <span class="dv">3</span> <span class="fu">:</span> map id []</a>
-<a class="sourceLine" id="cb187-7" data-line-number="7">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">2</span> <span class="fu">:</span> <span class="dv">3</span> <span class="fu">:</span> []</a>
-<a class="sourceLine" id="cb187-8" data-line-number="8">                <span class="fu">===</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb187"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb187-1" title="1"><span class="fu">fmap</span> <span class="fu">id</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="fu">map</span> <span class="fu">id</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb187-2" title="2">                <span class="fu">==&gt;</span> <span class="fu">map</span> <span class="fu">id</span> (<span class="dv">1</span><span class="fu">:</span>[<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb187-3" title="3">                <span class="fu">==&gt;</span> <span class="fu">id</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">id</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb187-4" title="4">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">id</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb187-5" title="5">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">id</span> <span class="dv">2</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">id</span> [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb187-6" title="6">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">2</span> <span class="fu">:</span> <span class="fu">id</span> <span class="dv">3</span> <span class="fu">:</span> <span class="fu">map</span> <span class="fu">id</span> []</a>
+<a class="sourceLine" id="cb187-7" title="7">                <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">2</span> <span class="fu">:</span> <span class="dv">3</span> <span class="fu">:</span> []</a>
+<a class="sourceLine" id="cb187-8" title="8">                <span class="fu">===</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>On the other hand,</p>
-<div class="sourceCode" id="cb188"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb188-1" data-line-number="1">id [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb188"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb188-1" title="1"><span class="fu">id</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>Hence, the result of <code>fmap id [1,2,3]</code> was the same as the result of <code>id [1,2,3]</code>, so the first functor law holds in this case. It’s not hard to show that the first functor law holds for any list whatsoever.</p>
 <p>The first functor law is really a very simple proposition if you think about it. It just says that if we apply <code>fmap</code> to a function that changes nothing (<code>id</code>) the resulting function (<code>fmap id</code>) again changes nothing. Thus, the act of applying <code>fmap</code> itself preserves the structure of the functor.</p>
 <p>How about the second functor law? For lists, consider what happens if we <code>fmap</code> the function <code>negate.(*2)</code> (remember, <code>negate</code> maps <code>x</code> to <code>-x</code> and <code>(*2)</code> multiplies its argument by <code>2</code>):</p>
-<div class="sourceCode" id="cb189"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb189-1" data-line-number="1">fmap (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-2" data-line-number="2">                           <span class="fu">==&gt;</span> (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">1</span> <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-3" data-line-number="3">                           <span class="fu">==&gt;</span> negate (<span class="dv">1</span> <span class="fu">*</span> <span class="dv">2</span>)  <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-4" data-line-number="4">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-5" data-line-number="5">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">2</span> <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-6" data-line-number="6">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb189-7" data-line-number="7">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">3</span> <span class="fu">:</span> map (negate<span class="fu">.</span>(<span class="fu">*</span><span class="dv">2</span>)) []</a>
-<a class="sourceLine" id="cb189-8" data-line-number="8">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">6</span> <span class="fu">:</span> []</a>
-<a class="sourceLine" id="cb189-9" data-line-number="9">                           <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb189"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb189-1" title="1"><span class="fu">fmap</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-2" title="2">                           <span class="fu">==&gt;</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">1</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-3" title="3">                           <span class="fu">==&gt;</span> <span class="fu">negate</span> (<span class="dv">1</span> <span class="fu">*</span> <span class="dv">2</span>)  <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-4" title="4">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-5" title="5">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">2</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-6" title="6">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb189-7" title="7">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) <span class="dv">3</span> <span class="fu">:</span> <span class="fu">map</span> (<span class="fu">negate.</span>(<span class="fu">*</span><span class="dv">2</span>)) []</a>
+<a class="sourceLine" id="cb189-8" title="8">                           <span class="fu">==&gt;</span> <span class="fu">-</span><span class="dv">2</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">4</span> <span class="fu">:</span> <span class="fu">-</span><span class="dv">6</span> <span class="fu">:</span> []</a>
+<a class="sourceLine" id="cb189-9" title="9">                           <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">6</span>]</a></code></pre></div>
 <p>Let’s consider the right-hand side of the second functor law in this case:</p>
-<div class="sourceCode" id="cb190"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb190-1" data-line-number="1">(fmap negate <span class="fu">.</span> fmap (<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> (map negate <span class="fu">.</span> map (<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb190-2" data-line-number="2">                                  <span class="fu">==&gt;</span> map negate (map (<span class="fu">*</span><span class="dv">2</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb190-3" data-line-number="3">                                  <span class="fu">==&gt;</span> map negate [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb190-4" data-line-number="4">                                  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">6</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb190"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb190-1" title="1">(<span class="fu">fmap</span> <span class="fu">negate</span> <span class="fu">.</span> <span class="fu">fmap</span> (<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> (<span class="fu">map</span> <span class="fu">negate</span> <span class="fu">.</span> <span class="fu">map</span> (<span class="fu">*</span><span class="dv">2</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb190-2" title="2">                                  <span class="fu">==&gt;</span> <span class="fu">map</span> <span class="fu">negate</span> (<span class="fu">map</span> (<span class="fu">*</span><span class="dv">2</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb190-3" title="3">                                  <span class="fu">==&gt;</span> <span class="fu">map</span> <span class="fu">negate</span> [<span class="dv">2</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb190-4" title="4">                                  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">6</span>]</a></code></pre></div>
 <p>The second functor law turns out to hold in this particular case. In fact, it holds in all cases (exercise!).</p>
 <p>In general, the second functor law says that composing two functions first and then applying <code>fmap</code> must yield the same result as performing <code>fmap</code> on those functions and then composing the resulting function. In other words, the order of applying <code>fmap</code> and composing doesn’t matter. (These two operations are said to <em>commute</em>.)</p>
 <!-- I don't know if this is helpful or more confusing:
@@ -2329,94 +2327,94 @@ necessary for having a concept like functor laws in a programming language so
 this topic connects to equational reasoning discussed in chapter 10.
 -->
 <p>There are also higher-order functions that fail to satisfy functor laws. Consider the function <code>badMap</code>:</p>
-<div class="sourceCode" id="cb191"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb191-1" data-line-number="1"><span class="ot">badMap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
-<a class="sourceLine" id="cb191-2" data-line-number="2">badMap f [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb191-3" data-line-number="3">badMap f (x<span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> badMap f xs</a>
-<a class="sourceLine" id="cb191-4" data-line-number="4">badMap f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> badMap f xs</a></code></pre></div>
+<div class="sourceCode" id="cb191"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb191-1" title="1"><span class="ot">badMap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [b]</a>
+<a class="sourceLine" id="cb191-2" title="2">badMap f [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb191-3" title="3">badMap f (x<span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> badMap f xs</a>
+<a class="sourceLine" id="cb191-4" title="4">badMap f (x<span class="fu">:</span>xs) <span class="fu">=</span> f x <span class="fu">:</span> badMap f xs</a></code></pre></div>
 <p>This function violates the first functor law. For instance:</p>
-<div class="sourceCode" id="cb192"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb192-1" data-line-number="1">badMap id [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> badMap id (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>[<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb192-2" data-line-number="2">                  <span class="fu">==&gt;</span> id <span class="dv">1</span> <span class="fu">:</span> badMap id [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb192-3" data-line-number="3">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> badMap id [<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb192-4" data-line-number="4">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> badMap id (<span class="dv">3</span><span class="fu">:</span>[])</a>
-<a class="sourceLine" id="cb192-5" data-line-number="5">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> id <span class="dv">3</span> <span class="fu">:</span> badMap id []</a>
-<a class="sourceLine" id="cb192-6" data-line-number="6">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">3</span> <span class="fu">:</span> []</a>
-<a class="sourceLine" id="cb192-7" data-line-number="7">                  <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb192"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb192-1" title="1">badMap <span class="fu">id</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> badMap <span class="fu">id</span> (<span class="dv">1</span><span class="fu">:</span><span class="dv">2</span><span class="fu">:</span>[<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb192-2" title="2">                  <span class="fu">==&gt;</span> <span class="fu">id</span> <span class="dv">1</span> <span class="fu">:</span> badMap <span class="fu">id</span> [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb192-3" title="3">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> badMap <span class="fu">id</span> [<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb192-4" title="4">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> badMap <span class="fu">id</span> (<span class="dv">3</span><span class="fu">:</span>[])</a>
+<a class="sourceLine" id="cb192-5" title="5">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="fu">id</span> <span class="dv">3</span> <span class="fu">:</span> badMap <span class="fu">id</span> []</a>
+<a class="sourceLine" id="cb192-6" title="6">                  <span class="fu">==&gt;</span> <span class="dv">1</span> <span class="fu">:</span> <span class="dv">3</span> <span class="fu">:</span> []</a>
+<a class="sourceLine" id="cb192-7" title="7">                  <span class="fu">==&gt;</span> [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>Applying <code>badMap id</code> to the list <code>[1,2,3]</code> changed the list as the element <code>2</code> was dropped.</p>
 <p>As mentioned, Haskell compilers can’t detect if a functor obeys its laws or not. A Haskell compiler would happily accept an instance <code>Functor []</code> that used <code>badMap</code> instead of <code>map</code> as the <code>fmap</code> implementation. This is a limitation of the type system of Haskell. There are technologies such as LiquidHaskell or dependently typed languages such as Agda, Idris, Coq, or Lean that could actually enforce functor laws so that unlawful functor instances wouldn’t compile. These technologies are outside the scope of this course, however.</p>
 <h2 id="sidenote-kinds"><span class="header-section-number">12.4</span> Sidenote: Kinds</h2>
 <p>Remember that <code>Functor</code> was a class for type constructors. If we try to define an instance of <code>Functor</code> for a type, we get an error:</p>
-<div class="sourceCode" id="cb193"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb193-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Int</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb193-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb193-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">18</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb193-4" data-line-number="4">    • <span class="dt">Expected</span> kind ‘<span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>’, but ‘<span class="dt">Int</span>’ has kind ‘<span class="fu">*</span>’</a>
-<a class="sourceLine" id="cb193-5" data-line-number="5">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘<span class="dt">Functor</span>’, namely ‘<span class="dt">Int</span>’</a>
-<a class="sourceLine" id="cb193-6" data-line-number="6">      <span class="dt">In</span> the <span class="kw">instance</span> declaration for ‘<span class="dt">Functor</span> <span class="dt">Int</span>’</a></code></pre></div>
+<div class="sourceCode" id="cb193"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb193-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Int</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb193-2" title="2"></a>
+<a class="sourceLine" id="cb193-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">1</span><span class="fu">:</span><span class="dv">18</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb193-4" title="4">    • <span class="dt">Expected</span> kind ‘<span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>’, but ‘<span class="dt">Int</span>’ has kind ‘<span class="fu">*</span>’</a>
+<a class="sourceLine" id="cb193-5" title="5">    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘<span class="dt">Functor</span>’, namely ‘<span class="dt">Int</span>’</a>
+<a class="sourceLine" id="cb193-6" title="6">      <span class="dt">In</span> the <span class="kw">instance</span> declaration for ‘<span class="dt">Functor</span> <span class="dt">Int</span>’</a></code></pre></div>
 <p>The error message talks about <em>kinds</em>. Kinds are <em>types of types</em>. A type like <code>Int</code>, <code>Bool</code> or <code>Maybe Int</code> that can contain values has kind <code>*</code>. A type constructor has a kind that looks like a function, for example, <code>Maybe</code> has kind <code>* -&gt; *</code>. This means that the <code>Maybe</code> type constructor must be applied to a type of kind <code>*</code> to get a type of kind <code>*</code>.</p>
 <p>We can ask GHCi for the kinds of types:</p>
-<div class="sourceCode" id="cb194"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb194-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb194-2" data-line-number="2"><span class="dt">Int</span><span class="ot"> ::</span> <span class="fu">*</span></a>
-<a class="sourceLine" id="cb194-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Maybe</span></a>
-<a class="sourceLine" id="cb194-4" data-line-number="4"><span class="dt">Maybe</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
-<a class="sourceLine" id="cb194-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb194-6" data-line-number="6"><span class="dt">Maybe</span> <span class="dt">Int</span><span class="ot"> ::</span> <span class="fu">*</span></a></code></pre></div>
+<div class="sourceCode" id="cb194"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb194-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb194-2" title="2"><span class="dt">Int</span><span class="ot"> ::</span> <span class="fu">*</span></a>
+<a class="sourceLine" id="cb194-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Maybe</span></a>
+<a class="sourceLine" id="cb194-4" title="4"><span class="dt">Maybe</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
+<a class="sourceLine" id="cb194-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb194-6" title="6"><span class="dt">Maybe</span> <span class="dt">Int</span><span class="ot"> ::</span> <span class="fu">*</span></a></code></pre></div>
 <p>If we ask GHCi for info about the <code>Functor</code> class, it tells us that instances of <code>Functor</code> must have kind <code>* -&gt; *</code>:</p>
-<div class="sourceCode" id="cb195"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb195-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Functor</span></a>
-<a class="sourceLine" id="cb195-2" data-line-number="2"><span class="kw">class</span> <span class="dt">Functor</span> (<span class="ot">f ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb195-3" data-line-number="3"><span class="ot">  fmap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb195-4" data-line-number="4"><span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb195"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb195-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Functor</span></a>
+<a class="sourceLine" id="cb195-2" title="2"><span class="kw">class</span> <span class="dt">Functor</span> (<span class="ot">f ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb195-3" title="3"><span class="ot">  fmap ::</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb195-4" title="4"><span class="fu">...</span></a></code></pre></div>
 <p>Here are some examples of even more complex kinds.</p>
-<div class="sourceCode" id="cb196"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb196-1" data-line-number="1"><span class="co">-- multiple type parameters</span></a>
-<a class="sourceLine" id="cb196-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Either</span></a>
-<a class="sourceLine" id="cb196-3" data-line-number="3"><span class="dt">Either</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
-<a class="sourceLine" id="cb196-4" data-line-number="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">Either3</span> a b c <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Middle</span> b <span class="fu">|</span> <span class="dt">Right</span> c</a>
-<a class="sourceLine" id="cb196-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Either3</span></a>
-<a class="sourceLine" id="cb196-6" data-line-number="6"><span class="dt">Either3</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
-<a class="sourceLine" id="cb196-7" data-line-number="7"><span class="co">-- a type parameter of kind *-&gt;*</span></a>
-<a class="sourceLine" id="cb196-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">IntInside</span> f <span class="fu">=</span> <span class="dt">IntInside</span> (f <span class="dt">Int</span>)</a>
-<a class="sourceLine" id="cb196-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">IntInside</span></a>
-<a class="sourceLine" id="cb196-10" data-line-number="10"><span class="dt">IntInside</span><span class="ot"> ::</span> (<span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>) <span class="ot">-&gt;</span> <span class="fu">*</span></a></code></pre></div>
+<div class="sourceCode" id="cb196"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb196-1" title="1"><span class="co">-- multiple type parameters</span></a>
+<a class="sourceLine" id="cb196-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Either</span></a>
+<a class="sourceLine" id="cb196-3" title="3"><span class="dt">Either</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
+<a class="sourceLine" id="cb196-4" title="4"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">Either3</span> a b c <span class="fu">=</span> <span class="dt">Left</span> a <span class="fu">|</span> <span class="dt">Middle</span> b <span class="fu">|</span> <span class="dt">Right</span> c</a>
+<a class="sourceLine" id="cb196-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">Either3</span></a>
+<a class="sourceLine" id="cb196-6" title="6"><span class="dt">Either3</span><span class="ot"> ::</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span></a>
+<a class="sourceLine" id="cb196-7" title="7"><span class="co">-- a type parameter of kind *-&gt;*</span></a>
+<a class="sourceLine" id="cb196-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">data</span> <span class="dt">IntInside</span> f <span class="fu">=</span> <span class="dt">IntInside</span> (f <span class="dt">Int</span>)</a>
+<a class="sourceLine" id="cb196-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>kind <span class="dt">IntInside</span></a>
+<a class="sourceLine" id="cb196-10" title="10"><span class="dt">IntInside</span><span class="ot"> ::</span> (<span class="fu">*</span> <span class="ot">-&gt;</span> <span class="fu">*</span>) <span class="ot">-&gt;</span> <span class="fu">*</span></a></code></pre></div>
 <p>You won’t bump into kinds that much in Haskell programming, but sometimes you’ll see error messages that talk about kinds, so it’s good to know what they are.</p>
 <h2 id="foldable-again"><span class="header-section-number">12.5</span> <code>Foldable</code>, Again</h2>
 <p>We briefly covered the class <code>Foldable</code>, which occurs in many type signatures of basic functions, in part 1. For example:</p>
-<div class="sourceCode" id="cb197"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb197-1" data-line-number="1">length<span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb197-2" data-line-number="2">sum<span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Num</span> a) <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb197-3" data-line-number="3">minimum<span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Ord</span> a) <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb197-4" data-line-number="4">foldMap<span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Monoid</span> m) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m</a></code></pre></div>
+<div class="sourceCode" id="cb197"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb197-1" title="1"><span class="fu">length</span><span class="ot"> ::</span> <span class="dt">Foldable</span> t <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb197-2" title="2"><span class="fu">sum</span><span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Num</span> a) <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb197-3" title="3"><span class="fu">minimum</span><span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Ord</span> a) <span class="ot">=&gt;</span> t a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb197-4" title="4"><span class="fu">foldMap</span><span class="ot"> ::</span> (<span class="dt">Foldable</span> t, <span class="dt">Monoid</span> m) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m</a></code></pre></div>
 <p>From these type signatures we can see that <code>Foldable</code>, just like <code>Functor</code>, is a class for type constructors (things of kind <code>* -&gt; *</code>). The essence of <code>Foldable</code> is to be a class for <em>things you can fold over</em>. The class definition could be as simple as</p>
-<div class="sourceCode" id="cb198"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb198-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Foldable</span> (<span class="ot">t ::</span> <span class="fu">*-&gt;*</span>) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb198-2" data-line-number="2"><span class="ot">  foldr ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb198"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb198-1" title="1"><span class="kw">class</span> <span class="dt">Foldable</span> (<span class="ot">t ::</span> <span class="fu">*-&gt;*</span>) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb198-2" title="2"><span class="ot">  foldr ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> b</a></code></pre></div>
 <p>However, for performance reasons, the class contains many methods (you can see them yourself by checking <code>:info Foldable</code> in GHCi!), but when we’re defining an instance for <code>Foldable</code> it’s enought to define just <code>foldr</code>.</p>
 <p>Another way of thinking of the <code>Foldable</code> class is processing elements <em>left-to-right</em>, in other words, if <code>Functor</code> was the class for containers, <code>Foldable</code> is the class for <em>ordered containers</em>.</p>
 <p>As an example, let’s implement <code>Functor</code> and <code>Foldable</code> for our own pair type.</p>
-<div class="sourceCode" id="cb199"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb199-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">Pair</span> a a</a>
-<a class="sourceLine" id="cb199-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb199-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb199-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Pair</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb199-5" data-line-number="5">  <span class="co">-- fmap f applies f to all values</span></a>
-<a class="sourceLine" id="cb199-6" data-line-number="6">  fmap f (<span class="dt">Pair</span> x y) <span class="fu">=</span> <span class="dt">Pair</span> (f x) (f y)</a>
-<a class="sourceLine" id="cb199-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb199-8" data-line-number="8"><span class="kw">instance</span> <span class="dt">Foldable</span> <span class="dt">Pair</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb199-9" data-line-number="9">  <span class="co">-- just like applying foldr over a list of length 2</span></a>
-<a class="sourceLine" id="cb199-10" data-line-number="10">  foldr f initialValue (<span class="dt">Pair</span> x y) <span class="fu">=</span> f x (f y initialValue)</a>
-<a class="sourceLine" id="cb199-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb199-12" data-line-number="12"><span class="co">-- an example function that uses both instances</span></a>
-<a class="sourceLine" id="cb199-13" data-line-number="13"><span class="ot">doubleAndCount ::</span> (<span class="dt">Functor</span> f, <span class="dt">Foldable</span> f) <span class="ot">=&gt;</span> f <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb199-14" data-line-number="14">doubleAndCount <span class="fu">=</span> sum <span class="fu">.</span> fmap (<span class="fu">*</span><span class="dv">2</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb199"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb199-1" title="1"><span class="kw">data</span> <span class="dt">Pair</span> a <span class="fu">=</span> <span class="dt">Pair</span> a a</a>
+<a class="sourceLine" id="cb199-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb199-3" title="3"></a>
+<a class="sourceLine" id="cb199-4" title="4"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Pair</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb199-5" title="5">  <span class="co">-- fmap f applies f to all values</span></a>
+<a class="sourceLine" id="cb199-6" title="6">  <span class="fu">fmap</span> f (<span class="dt">Pair</span> x y) <span class="fu">=</span> <span class="dt">Pair</span> (f x) (f y)</a>
+<a class="sourceLine" id="cb199-7" title="7"></a>
+<a class="sourceLine" id="cb199-8" title="8"><span class="kw">instance</span> <span class="dt">Foldable</span> <span class="dt">Pair</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb199-9" title="9">  <span class="co">-- just like applying foldr over a list of length 2</span></a>
+<a class="sourceLine" id="cb199-10" title="10">  <span class="fu">foldr</span> f initialValue (<span class="dt">Pair</span> x y) <span class="fu">=</span> f x (f y initialValue)</a>
+<a class="sourceLine" id="cb199-11" title="11"></a>
+<a class="sourceLine" id="cb199-12" title="12"><span class="co">-- an example function that uses both instances</span></a>
+<a class="sourceLine" id="cb199-13" title="13"><span class="ot">doubleAndCount ::</span> (<span class="dt">Functor</span> f, <span class="dt">Foldable</span> f) <span class="ot">=&gt;</span> f <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb199-14" title="14">doubleAndCount <span class="fu">=</span> <span class="fu">sum</span> <span class="fu">.</span> <span class="fu">fmap</span> (<span class="fu">*</span><span class="dv">2</span>)</a></code></pre></div>
 <p>Now, we can use <code>Pair</code> almost wherever we can use a list:</p>
-<div class="sourceCode" id="cb200"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb200-1" data-line-number="1">fmap (<span class="fu">+</span><span class="dv">1</span>) (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)   <span class="fu">==&gt;</span> <span class="dt">Pair</span> <span class="dv">4</span> <span class="dv">7</span></a>
-<a class="sourceLine" id="cb200-2" data-line-number="2">fmap (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">3</span>,<span class="dv">6</span>]        <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">7</span>]</a>
-<a class="sourceLine" id="cb200-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb200-4" data-line-number="4">foldr (<span class="fu">*</span>) <span class="dv">1</span> (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>) <span class="fu">==&gt;</span> <span class="dv">18</span></a>
-<a class="sourceLine" id="cb200-5" data-line-number="5">foldr (<span class="fu">*</span>) <span class="dv">1</span> [<span class="dv">3</span>,<span class="dv">6</span>]      <span class="fu">==&gt;</span> <span class="dv">18</span></a>
-<a class="sourceLine" id="cb200-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb200-7" data-line-number="7">length (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)      <span class="fu">==&gt;</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb200-8" data-line-number="8">length [<span class="dv">3</span>,<span class="dv">6</span>]           <span class="fu">==&gt;</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb200-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb200-10" data-line-number="10">minimum (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)     <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb200-11" data-line-number="11">minimum [<span class="dv">3</span>,<span class="dv">6</span>]          <span class="fu">==&gt;</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb200-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb200-13" data-line-number="13">doubleAndCount (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)  <span class="fu">==&gt;</span> <span class="dv">18</span></a>
-<a class="sourceLine" id="cb200-14" data-line-number="14">doubleAndCount [<span class="dv">3</span>,<span class="dv">6</span>]       <span class="fu">==&gt;</span> <span class="dv">18</span></a></code></pre></div>
+<div class="sourceCode" id="cb200"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb200-1" title="1"><span class="fu">fmap</span> (<span class="fu">+</span><span class="dv">1</span>) (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)   <span class="fu">==&gt;</span> <span class="dt">Pair</span> <span class="dv">4</span> <span class="dv">7</span></a>
+<a class="sourceLine" id="cb200-2" title="2"><span class="fu">fmap</span> (<span class="fu">+</span><span class="dv">1</span>) [<span class="dv">3</span>,<span class="dv">6</span>]        <span class="fu">==&gt;</span> [<span class="dv">4</span>,<span class="dv">7</span>]</a>
+<a class="sourceLine" id="cb200-3" title="3"></a>
+<a class="sourceLine" id="cb200-4" title="4"><span class="fu">foldr</span> (<span class="fu">*</span>) <span class="dv">1</span> (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>) <span class="fu">==&gt;</span> <span class="dv">18</span></a>
+<a class="sourceLine" id="cb200-5" title="5"><span class="fu">foldr</span> (<span class="fu">*</span>) <span class="dv">1</span> [<span class="dv">3</span>,<span class="dv">6</span>]      <span class="fu">==&gt;</span> <span class="dv">18</span></a>
+<a class="sourceLine" id="cb200-6" title="6"></a>
+<a class="sourceLine" id="cb200-7" title="7"><span class="fu">length</span> (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)      <span class="fu">==&gt;</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb200-8" title="8"><span class="fu">length</span> [<span class="dv">3</span>,<span class="dv">6</span>]           <span class="fu">==&gt;</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb200-9" title="9"></a>
+<a class="sourceLine" id="cb200-10" title="10"><span class="fu">minimum</span> (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)     <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb200-11" title="11"><span class="fu">minimum</span> [<span class="dv">3</span>,<span class="dv">6</span>]          <span class="fu">==&gt;</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb200-12" title="12"></a>
+<a class="sourceLine" id="cb200-13" title="13">doubleAndCount (<span class="dt">Pair</span> <span class="dv">3</span> <span class="dv">6</span>)  <span class="fu">==&gt;</span> <span class="dv">18</span></a>
+<a class="sourceLine" id="cb200-14" title="14">doubleAndCount [<span class="dv">3</span>,<span class="dv">6</span>]       <span class="fu">==&gt;</span> <span class="dv">18</span></a></code></pre></div>
 <p>Other types we’ve met that are <code>Foldable</code> include <code>Data.Map</code> and <code>Data.Array</code>.</p>
 <h2 id="recap"><span class="header-section-number">12.6</span> Recap</h2>
 <p>So, to summarize, a functor is a type constructor <code>f</code> and the corresponding <code>Functor f</code> instance such that <code>fmap</code> satisfies the two functor laws. These laws assert that <code>fmap</code> must preserve the identity function and distribute over function composition. More informally, <code>fmap</code> lifts a function <code>g :: a -&gt; b</code> operating on values to one operating on containers: <code>fmap g :: f a -&gt; f b</code>. Basically all well-behaving data structures in Haskell are functors.</p>
@@ -2438,10 +2436,10 @@ this topic connects to equational reasoning discussed in chapter 10.
 </li>
 </ol>
 <p>Which code snippet completes the next <code>Functor</code> instance?</p>
-<div class="sourceCode" id="cb201"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb201-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Container</span> x <span class="fu">=</span> <span class="dt">Things</span> x [x]</a>
-<a class="sourceLine" id="cb201-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb201-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Container</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb201-4" data-line-number="4">  <span class="fu">????</span></a></code></pre></div>
+<div class="sourceCode" id="cb201"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb201-1" title="1"><span class="kw">data</span> <span class="dt">Container</span> x <span class="fu">=</span> <span class="dt">Things</span> x [x]</a>
+<a class="sourceLine" id="cb201-2" title="2"></a>
+<a class="sourceLine" id="cb201-3" title="3"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Container</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb201-4" title="4">  <span class="fu">????</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>fmap f (Things x ys) = Things (f x) [f x]</code>
@@ -2469,7 +2467,7 @@ this topic connects to equational reasoning discussed in chapter 10.
 </li>
 </ol>
 <p>What’s the kind of <code>Foo</code>?</p>
-<div class="sourceCode" id="cb202"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb202-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Foo</span> x <span class="fu">=</span> <span class="dt">FooConst</span></a></code></pre></div>
+<div class="sourceCode" id="cb202"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb202-1" title="1"><span class="kw">data</span> <span class="dt">Foo</span> x <span class="fu">=</span> <span class="dt">FooConst</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>*</code>
@@ -2482,7 +2480,7 @@ this topic connects to equational reasoning discussed in chapter 10.
 </li>
 </ol>
 <p>What’s the kind of <code>Bar</code>?</p>
-<div class="sourceCode" id="cb203"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb203-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Bar</span> <span class="fu">=</span> <span class="dt">Baz</span> <span class="fu">|</span> <span class="dt">Qux</span> <span class="dt">Int</span></a></code></pre></div>
+<div class="sourceCode" id="cb203"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb203-1" title="1"><span class="kw">data</span> <span class="dt">Bar</span> <span class="fu">=</span> <span class="dt">Baz</span> <span class="fu">|</span> <span class="dt">Qux</span> <span class="dt">Int</span></a></code></pre></div>
 <ol class="quiz">
 <li class="correct">
 <code>*</code>
@@ -2510,10 +2508,10 @@ this topic connects to equational reasoning discussed in chapter 10.
 </li>
 </ol>
 <p>Which code snippet completes the next <code>Foldable</code> instance?</p>
-<div class="sourceCode" id="cb204"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb204-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Container</span> x <span class="fu">=</span> <span class="dt">Things</span> x [x]</a>
-<a class="sourceLine" id="cb204-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb204-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">Foldable</span> <span class="dt">Container</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb204-4" data-line-number="4">  <span class="fu">????</span></a></code></pre></div>
+<div class="sourceCode" id="cb204"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb204-1" title="1"><span class="kw">data</span> <span class="dt">Container</span> x <span class="fu">=</span> <span class="dt">Things</span> x [x]</a>
+<a class="sourceLine" id="cb204-2" title="2"></a>
+<a class="sourceLine" id="cb204-3" title="3"><span class="kw">instance</span> <span class="dt">Foldable</span> <span class="dt">Container</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb204-4" title="4">  <span class="fu">????</span></a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>foldr f z (Things x ys) = f x z</code>
@@ -2543,729 +2541,729 @@ this topic connects to equational reasoning discussed in chapter 10.
 <p>One final word of caution: monads, like functors, are a concept originally from a branch of mathematics called Category Theory. However, and I can’t stress this enough, <em>you do not need to know anything or even care about category theory to understand monads in Haskell programming.</em> Just like one can work with object-oriented programming or functional programming without knowing the theory of objects or functions, one can work with monads without understanding the math associated with them. Category theory can be a rewarding topic for a functional programmer, but it’s not a mandatory one.</p>
 <h2 id="example-1-maybes"><span class="header-section-number">13.1</span> Example 1: Maybes</h2>
 <p>When working with many <code>Maybe</code> values, the code tends to become a bit messy. Let’s look at some examples. First, we combine some functions returning <code>Maybe String</code>. Note the nested <code>case</code> we need in <code>stealSecret</code>: It’s not fun to write.</p>
-<div class="sourceCode" id="cb205"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb205-1" data-line-number="1"><span class="co">-- Try to login with a password.</span></a>
-<a class="sourceLine" id="cb205-2" data-line-number="2"><span class="co">-- `Just username` on success, `Nothing` otherwise.</span></a>
-<a class="sourceLine" id="cb205-3" data-line-number="3"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb205-4" data-line-number="4">login <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;unicorn73&quot;</span></a>
-<a class="sourceLine" id="cb205-5" data-line-number="5">login <span class="st">&quot;swordfish&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;megahacker&quot;</span></a>
-<a class="sourceLine" id="cb205-6" data-line-number="6">login _           <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb205-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb205-8" data-line-number="8"><span class="co">-- Get a secret associated with a user.</span></a>
-<a class="sourceLine" id="cb205-9" data-line-number="9"><span class="co">-- Not all users have secrets.</span></a>
-<a class="sourceLine" id="cb205-10" data-line-number="10"><span class="ot">secret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb205-11" data-line-number="11">secret <span class="st">&quot;megahacker&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;I like roses&quot;</span></a>
-<a class="sourceLine" id="cb205-12" data-line-number="12">secret _            <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb205-13" data-line-number="13"></a>
-<a class="sourceLine" id="cb205-14" data-line-number="14"><span class="co">-- Login and return the user&#39;s secret, if any</span></a>
-<a class="sourceLine" id="cb205-15" data-line-number="15"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb205-16" data-line-number="16">stealSecret password <span class="fu">=</span></a>
-<a class="sourceLine" id="cb205-17" data-line-number="17">  <span class="kw">case</span> login password <span class="kw">of</span></a>
-<a class="sourceLine" id="cb205-18" data-line-number="18">    <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb205-19" data-line-number="19">    <span class="dt">Just</span> user <span class="ot">-&gt;</span> <span class="kw">case</span> secret user <span class="kw">of</span></a>
-<a class="sourceLine" id="cb205-20" data-line-number="20">                   <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb205-21" data-line-number="21">                   <span class="dt">Just</span> s <span class="ot">-&gt;</span> <span class="dt">Just</span> (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
-<div class="sourceCode" id="cb206"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb206-1" data-line-number="1">stealSecret <span class="st">&quot;swordfish&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;Stole secret: I like roses&quot;</span></a>
-<a class="sourceLine" id="cb206-2" data-line-number="2">stealSecret <span class="st">&quot;f4bulous!&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb206-3" data-line-number="3">stealSecret <span class="st">&quot;wrong_password&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb205"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb205-1" title="1"><span class="co">-- Try to login with a password.</span></a>
+<a class="sourceLine" id="cb205-2" title="2"><span class="co">-- `Just username` on success, `Nothing` otherwise.</span></a>
+<a class="sourceLine" id="cb205-3" title="3"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb205-4" title="4">login <span class="st">&quot;f4bulous!&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;unicorn73&quot;</span></a>
+<a class="sourceLine" id="cb205-5" title="5">login <span class="st">&quot;swordfish&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;megahacker&quot;</span></a>
+<a class="sourceLine" id="cb205-6" title="6">login _           <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb205-7" title="7"></a>
+<a class="sourceLine" id="cb205-8" title="8"><span class="co">-- Get a secret associated with a user.</span></a>
+<a class="sourceLine" id="cb205-9" title="9"><span class="co">-- Not all users have secrets.</span></a>
+<a class="sourceLine" id="cb205-10" title="10"><span class="ot">secret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb205-11" title="11">secret <span class="st">&quot;megahacker&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="st">&quot;I like roses&quot;</span></a>
+<a class="sourceLine" id="cb205-12" title="12">secret _            <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb205-13" title="13"></a>
+<a class="sourceLine" id="cb205-14" title="14"><span class="co">-- Login and return the user&#39;s secret, if any</span></a>
+<a class="sourceLine" id="cb205-15" title="15"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb205-16" title="16">stealSecret password <span class="fu">=</span></a>
+<a class="sourceLine" id="cb205-17" title="17">  <span class="kw">case</span> login password <span class="kw">of</span></a>
+<a class="sourceLine" id="cb205-18" title="18">    <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb205-19" title="19">    <span class="dt">Just</span> user <span class="ot">-&gt;</span> <span class="kw">case</span> secret user <span class="kw">of</span></a>
+<a class="sourceLine" id="cb205-20" title="20">                   <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb205-21" title="21">                   <span class="dt">Just</span> s <span class="ot">-&gt;</span> <span class="dt">Just</span> (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
+<div class="sourceCode" id="cb206"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb206-1" title="1">stealSecret <span class="st">&quot;swordfish&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="st">&quot;Stole secret: I like roses&quot;</span></a>
+<a class="sourceLine" id="cb206-2" title="2">stealSecret <span class="st">&quot;f4bulous!&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb206-3" title="3">stealSecret <span class="st">&quot;wrong_password&quot;</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a></code></pre></div>
 <p>Next up, we modify a list of pairs. We use the <code>Maybe</code>-returning function <code>lookup</code> from the Prelude. Here we have an if inside a case instead of a nested case.</p>
-<div class="sourceCode" id="cb207"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb207-1" data-line-number="1"><span class="co">-- Get the value corresponding to a key from a key-value list.</span></a>
-<a class="sourceLine" id="cb207-2" data-line-number="2">lookup<span class="ot"> ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> [(a, b)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a></code></pre></div>
-<div class="sourceCode" id="cb208"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb208-1" data-line-number="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
-<a class="sourceLine" id="cb208-2" data-line-number="2"><span class="co">-- but only if val is larger than the current value!</span></a>
-<a class="sourceLine" id="cb208-3" data-line-number="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb208-4" data-line-number="4">increase key val assocs <span class="fu">=</span></a>
-<a class="sourceLine" id="cb208-5" data-line-number="5">  <span class="kw">case</span> lookup key assocs</a>
-<a class="sourceLine" id="cb208-6" data-line-number="6">  <span class="kw">of</span> <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb208-7" data-line-number="7">     <span class="dt">Just</span> x <span class="ot">-&gt;</span> <span class="kw">if</span> (val <span class="fu">&lt;</span> x)</a>
-<a class="sourceLine" id="cb208-8" data-line-number="8">                <span class="kw">then</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb208-9" data-line-number="9">                <span class="kw">else</span> <span class="dt">Just</span> ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
+<div class="sourceCode" id="cb207"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb207-1" title="1"><span class="co">-- Get the value corresponding to a key from a key-value list.</span></a>
+<a class="sourceLine" id="cb207-2" title="2"><span class="fu">lookup</span><span class="ot"> ::</span> (<span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> [(a, b)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb208"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb208-1" title="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
+<a class="sourceLine" id="cb208-2" title="2"><span class="co">-- but only if val is larger than the current value!</span></a>
+<a class="sourceLine" id="cb208-3" title="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb208-4" title="4">increase key val assocs <span class="fu">=</span></a>
+<a class="sourceLine" id="cb208-5" title="5">  <span class="kw">case</span> <span class="fu">lookup</span> key assocs</a>
+<a class="sourceLine" id="cb208-6" title="6">  <span class="kw">of</span> <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb208-7" title="7">     <span class="dt">Just</span> x <span class="ot">-&gt;</span> <span class="kw">if</span> (val <span class="fu">&lt;</span> x)</a>
+<a class="sourceLine" id="cb208-8" title="8">                <span class="kw">then</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb208-9" title="9">                <span class="kw">else</span> <span class="dt">Just</span> ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
 <p>This type of code is pretty common, and usually repeats the same pattern: if any intermediate result is <code>Nothing</code>, the whole result is <code>Nothing</code>. Let’s try to make writing code like this easier by defining a <em>chaining operator</em> <code>?&gt;</code>. The chaining operator takes a result and the next step of computation, and only runs the next step if the result was a <code>Just</code> value.</p>
-<div class="sourceCode" id="cb209"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb209-1" data-line-number="1"><span class="ot">(?&gt;) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb209-2" data-line-number="2"><span class="co">-- if we failed, don&#39;t even bother running the next step:</span></a>
-<a class="sourceLine" id="cb209-3" data-line-number="3"><span class="dt">Nothing</span> <span class="fu">?&gt;</span> _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb209-4" data-line-number="4"><span class="co">-- otherwise run the next step:</span></a>
-<a class="sourceLine" id="cb209-5" data-line-number="5"><span class="dt">Just</span> x  <span class="fu">?&gt;</span> f <span class="fu">=</span> f x</a></code></pre></div>
+<div class="sourceCode" id="cb209"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb209-1" title="1"><span class="ot">(?&gt;) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb209-2" title="2"><span class="co">-- if we failed, don&#39;t even bother running the next step:</span></a>
+<a class="sourceLine" id="cb209-3" title="3"><span class="dt">Nothing</span> <span class="fu">?&gt;</span> _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb209-4" title="4"><span class="co">-- otherwise run the next step:</span></a>
+<a class="sourceLine" id="cb209-5" title="5"><span class="dt">Just</span> x  <span class="fu">?&gt;</span> f <span class="fu">=</span> f x</a></code></pre></div>
 <p>The chaining operator streamlines our examples nicely. Note how we can define simple helper functions that take care of one step of the computation instead of writing one big expression.</p>
-<div class="sourceCode" id="cb210"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb210-1" data-line-number="1"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb210-2" data-line-number="2">stealSecret password <span class="fu">=</span></a>
-<a class="sourceLine" id="cb210-3" data-line-number="3">    login password <span class="fu">?&gt;</span></a>
-<a class="sourceLine" id="cb210-4" data-line-number="4">    secret <span class="fu">?&gt;</span></a>
-<a class="sourceLine" id="cb210-5" data-line-number="5">    decorate</a>
-<a class="sourceLine" id="cb210-6" data-line-number="6">  <span class="kw">where</span> decorate s <span class="fu">=</span> <span class="dt">Just</span> (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
-<div class="sourceCode" id="cb211"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb211-1" data-line-number="1"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb211-2" data-line-number="2">increase key val assocs <span class="fu">=</span></a>
-<a class="sourceLine" id="cb211-3" data-line-number="3">    lookup key assocs <span class="fu">?&gt;</span></a>
-<a class="sourceLine" id="cb211-4" data-line-number="4">    check <span class="fu">?&gt;</span></a>
-<a class="sourceLine" id="cb211-5" data-line-number="5">    buildResult</a>
-<a class="sourceLine" id="cb211-6" data-line-number="6">  <span class="kw">where</span> check x</a>
-<a class="sourceLine" id="cb211-7" data-line-number="7">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb211-8" data-line-number="8">           <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb211-9" data-line-number="9">        buildResult x <span class="fu">=</span> <span class="dt">Just</span> ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
+<div class="sourceCode" id="cb210"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb210-1" title="1"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb210-2" title="2">stealSecret password <span class="fu">=</span></a>
+<a class="sourceLine" id="cb210-3" title="3">    login password <span class="fu">?&gt;</span></a>
+<a class="sourceLine" id="cb210-4" title="4">    secret <span class="fu">?&gt;</span></a>
+<a class="sourceLine" id="cb210-5" title="5">    decorate</a>
+<a class="sourceLine" id="cb210-6" title="6">  <span class="kw">where</span> decorate s <span class="fu">=</span> <span class="dt">Just</span> (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
+<div class="sourceCode" id="cb211"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb211-1" title="1"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb211-2" title="2">increase key val assocs <span class="fu">=</span></a>
+<a class="sourceLine" id="cb211-3" title="3">    <span class="fu">lookup</span> key assocs <span class="fu">?&gt;</span></a>
+<a class="sourceLine" id="cb211-4" title="4">    check <span class="fu">?&gt;</span></a>
+<a class="sourceLine" id="cb211-5" title="5">    buildResult</a>
+<a class="sourceLine" id="cb211-6" title="6">  <span class="kw">where</span> check x</a>
+<a class="sourceLine" id="cb211-7" title="7">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb211-8" title="8">           <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb211-9" title="9">        buildResult x <span class="fu">=</span> <span class="dt">Just</span> ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
 <p>Here’s another example: safe list indexing built from <code>safeHead</code> and <code>safeTail</code>:</p>
-<div class="sourceCode" id="cb212"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb212-1" data-line-number="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb212-2" data-line-number="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb212-3" data-line-number="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb212-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb212-5" data-line-number="5"><span class="ot">safeTail ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
-<a class="sourceLine" id="cb212-6" data-line-number="6">safeTail [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb212-7" data-line-number="7">safeTail (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> xs</a>
-<a class="sourceLine" id="cb212-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb212-9" data-line-number="9"><span class="ot">safeThird ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb212-10" data-line-number="10">safeThird xs <span class="fu">=</span> safeTail xs <span class="fu">?&gt;</span> safeTail <span class="fu">?&gt;</span> safeHead</a>
-<a class="sourceLine" id="cb212-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb212-12" data-line-number="12"><span class="ot">safeNth ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb212-13" data-line-number="13">safeNth <span class="dv">0</span> xs <span class="fu">=</span> safeHead xs</a>
-<a class="sourceLine" id="cb212-14" data-line-number="14">safeNth n xs <span class="fu">=</span> safeTail xs <span class="fu">?&gt;</span> safeNth (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb213"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb213-1" data-line-number="1">safeThird [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb213-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb213-3" data-line-number="3">safeThird [<span class="dv">1</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb213-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb213-5" data-line-number="5">safeNth <span class="dv">5</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">10</span>]</a>
-<a class="sourceLine" id="cb213-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">6</span></a>
-<a class="sourceLine" id="cb213-7" data-line-number="7">safeNth <span class="dv">11</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">10</span>]</a>
-<a class="sourceLine" id="cb213-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb212"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb212-1" title="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb212-2" title="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb212-3" title="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb212-4" title="4"></a>
+<a class="sourceLine" id="cb212-5" title="5"><span class="ot">safeTail ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
+<a class="sourceLine" id="cb212-6" title="6">safeTail [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb212-7" title="7">safeTail (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> xs</a>
+<a class="sourceLine" id="cb212-8" title="8"></a>
+<a class="sourceLine" id="cb212-9" title="9"><span class="ot">safeThird ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb212-10" title="10">safeThird xs <span class="fu">=</span> safeTail xs <span class="fu">?&gt;</span> safeTail <span class="fu">?&gt;</span> safeHead</a>
+<a class="sourceLine" id="cb212-11" title="11"></a>
+<a class="sourceLine" id="cb212-12" title="12"><span class="ot">safeNth ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb212-13" title="13">safeNth <span class="dv">0</span> xs <span class="fu">=</span> safeHead xs</a>
+<a class="sourceLine" id="cb212-14" title="14">safeNth n xs <span class="fu">=</span> safeTail xs <span class="fu">?&gt;</span> safeNth (n<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb213"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb213-1" title="1">safeThird [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb213-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb213-3" title="3">safeThird [<span class="dv">1</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb213-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb213-5" title="5">safeNth <span class="dv">5</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">10</span>]</a>
+<a class="sourceLine" id="cb213-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">6</span></a>
+<a class="sourceLine" id="cb213-7" title="7">safeNth <span class="dv">11</span> [<span class="dv">1</span><span class="fu">..</span><span class="dv">10</span>]</a>
+<a class="sourceLine" id="cb213-8" title="8">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>PS. note that <code>?&gt;</code> <em>associates to the left</em> as is the default in Haskell. That means that <code>op ?&gt; f ?&gt; g</code> means <code>(op ?&gt; f) ?&gt; g</code>. The alternative, <code>op ?&gt; (f ?&gt; g)</code> would not even type check!</p>
 <p>Sidenote: this <code>?&gt;</code> operator expresses the if-result pattern that’s very common in other languages. Here is how one would write <code>op val ?&gt; f</code> in Python and Java.</p>
-<div class="sourceCode" id="cb214"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb214-1" data-line-number="1"><span class="co"># Python</span></a>
-<a class="sourceLine" id="cb214-2" data-line-number="2">x <span class="op">=</span> op(val)</a>
-<a class="sourceLine" id="cb214-3" data-line-number="3"><span class="cf">if</span> x:</a>
-<a class="sourceLine" id="cb214-4" data-line-number="4">  f x</a></code></pre></div>
-<div class="sourceCode" id="cb215"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb215-1" data-line-number="1"><span class="co">// Java</span></a>
-<a class="sourceLine" id="cb215-2" data-line-number="2"><span class="bu">Object</span> x = <span class="fu">op</span>(val);</a>
-<a class="sourceLine" id="cb215-3" data-line-number="3"><span class="kw">if</span> (x != <span class="kw">null</span>) {</a>
-<a class="sourceLine" id="cb215-4" data-line-number="4">  <span class="fu">f</span>(x);</a>
-<a class="sourceLine" id="cb215-5" data-line-number="5">}</a></code></pre></div>
+<div class="sourceCode" id="cb214"><pre class="sourceCode python"><code class="sourceCode python"><a class="sourceLine" id="cb214-1" title="1"><span class="co"># Python</span></a>
+<a class="sourceLine" id="cb214-2" title="2">x <span class="op">=</span> op(val)</a>
+<a class="sourceLine" id="cb214-3" title="3"><span class="cf">if</span> x:</a>
+<a class="sourceLine" id="cb214-4" title="4">  f x</a></code></pre></div>
+<div class="sourceCode" id="cb215"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb215-1" title="1"><span class="co">// Java</span></a>
+<a class="sourceLine" id="cb215-2" title="2"><span class="bu">Object</span> x = <span class="fu">op</span>(val);</a>
+<a class="sourceLine" id="cb215-3" title="3"><span class="kw">if</span> (x != <span class="kw">null</span>) {</a>
+<a class="sourceLine" id="cb215-4" title="4">  <span class="fu">f</span>(x);</a>
+<a class="sourceLine" id="cb215-5" title="5">}</a></code></pre></div>
 <p>The difference between the if-result pattern and our <code>?&gt;</code> is that we use the <code>Nothing</code> value to explicitly signal failure, instead of relying on the fact that any variable can be <code>None</code> (or <code>False</code>) in Python, or that any <code>Object</code> reference can be <code>null</code> in Java.</p>
 <h2 id="example-2-logging"><span class="header-section-number">13.2</span> Example 2: Logging</h2>
 <p>Let’s explore the concept of chaining with another example: logging. The type <code>Logger</code> represents a value plus a list of log messages (produced by the computation that produced the value).</p>
-<div class="sourceCode" id="cb216"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb216-1" data-line-number="1"><span class="co">-- Logger definition</span></a>
-<a class="sourceLine" id="cb216-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Logger</span> a <span class="fu">=</span> <span class="dt">Logger</span> [<span class="dt">String</span>] a  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb216-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb216-4" data-line-number="4"><span class="ot">getVal ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> a</a>
-<a class="sourceLine" id="cb216-5" data-line-number="5">getVal (<span class="dt">Logger</span> _ a) <span class="fu">=</span> a</a>
-<a class="sourceLine" id="cb216-6" data-line-number="6"><span class="ot">getLog ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb216-7" data-line-number="7">getLog (<span class="dt">Logger</span> s _) <span class="fu">=</span> s</a>
-<a class="sourceLine" id="cb216-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb216-9" data-line-number="9"><span class="co">-- Primitive operations:</span></a>
-<a class="sourceLine" id="cb216-10" data-line-number="10"><span class="ot">nomsg ::</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
-<a class="sourceLine" id="cb216-11" data-line-number="11">nomsg x <span class="fu">=</span> <span class="dt">Logger</span> [] x        <span class="co">-- a value, no message</span></a>
-<a class="sourceLine" id="cb216-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb216-13" data-line-number="13"><span class="ot">annotate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
-<a class="sourceLine" id="cb216-14" data-line-number="14">annotate s x <span class="fu">=</span> <span class="dt">Logger</span> [s] x  <span class="co">-- a value and a message</span></a>
-<a class="sourceLine" id="cb216-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb216-16" data-line-number="16"><span class="ot">msg ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
-<a class="sourceLine" id="cb216-17" data-line-number="17">msg s <span class="fu">=</span> <span class="dt">Logger</span> [s] ()        <span class="co">-- just a message</span></a></code></pre></div>
+<div class="sourceCode" id="cb216"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb216-1" title="1"><span class="co">-- Logger definition</span></a>
+<a class="sourceLine" id="cb216-2" title="2"><span class="kw">data</span> <span class="dt">Logger</span> a <span class="fu">=</span> <span class="dt">Logger</span> [<span class="dt">String</span>] a  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb216-3" title="3"></a>
+<a class="sourceLine" id="cb216-4" title="4"><span class="ot">getVal ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> a</a>
+<a class="sourceLine" id="cb216-5" title="5">getVal (<span class="dt">Logger</span> _ a) <span class="fu">=</span> a</a>
+<a class="sourceLine" id="cb216-6" title="6"><span class="ot">getLog ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb216-7" title="7">getLog (<span class="dt">Logger</span> s _) <span class="fu">=</span> s</a>
+<a class="sourceLine" id="cb216-8" title="8"></a>
+<a class="sourceLine" id="cb216-9" title="9"><span class="co">-- Primitive operations:</span></a>
+<a class="sourceLine" id="cb216-10" title="10"><span class="ot">nomsg ::</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
+<a class="sourceLine" id="cb216-11" title="11">nomsg x <span class="fu">=</span> <span class="dt">Logger</span> [] x        <span class="co">-- a value, no message</span></a>
+<a class="sourceLine" id="cb216-12" title="12"></a>
+<a class="sourceLine" id="cb216-13" title="13"><span class="ot">annotate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
+<a class="sourceLine" id="cb216-14" title="14">annotate s x <span class="fu">=</span> <span class="dt">Logger</span> [s] x  <span class="co">-- a value and a message</span></a>
+<a class="sourceLine" id="cb216-15" title="15"></a>
+<a class="sourceLine" id="cb216-16" title="16"><span class="ot">msg ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
+<a class="sourceLine" id="cb216-17" title="17">msg s <span class="fu">=</span> <span class="dt">Logger</span> [s] ()        <span class="co">-- just a message</span></a></code></pre></div>
 <p>Here’s a <code>login</code> function that logs some details about the usernames and passwords it processes. Note how we run into complicated code in <code>login</code> when we need to handle multiple <code>Logger</code> values.</p>
-<div class="sourceCode" id="cb217"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb217-1" data-line-number="1"><span class="ot">validateUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb217-2" data-line-number="2">validateUser <span class="st">&quot;paul.atreides&quot;</span> <span class="fu">=</span> annotate <span class="st">&quot;Valid user&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb217-3" data-line-number="3">validateUser <span class="st">&quot;ninja&quot;</span> <span class="fu">=</span> nomsg <span class="dt">True</span></a>
-<a class="sourceLine" id="cb217-4" data-line-number="4">validateUser u <span class="fu">=</span> annotate (<span class="st">&quot;Invalid user: &quot;</span><span class="fu">++</span>u) <span class="dt">False</span></a>
-<a class="sourceLine" id="cb217-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb217-6" data-line-number="6"><span class="ot">checkPassword ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb217-7" data-line-number="7">checkPassword <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;muad&#39;dib&quot;</span> <span class="fu">=</span> annotate <span class="st">&quot;Password ok&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb217-8" data-line-number="8">checkPassword <span class="st">&quot;ninja&quot;</span>         <span class="st">&quot;&quot;</span>         <span class="fu">=</span> annotate <span class="st">&quot;Password ok&quot;</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb217-9" data-line-number="9">checkPassword _               pass       <span class="fu">=</span> annotate (<span class="st">&quot;Password wrong: &quot;</span><span class="fu">++</span>pass) <span class="dt">False</span></a>
-<a class="sourceLine" id="cb217-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb217-11" data-line-number="11"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb217-12" data-line-number="12">login user password <span class="fu">=</span></a>
-<a class="sourceLine" id="cb217-13" data-line-number="13">  <span class="kw">let</span> validation <span class="fu">=</span> validateUser user</a>
-<a class="sourceLine" id="cb217-14" data-line-number="14">  <span class="kw">in</span> <span class="kw">if</span> (getVal validation)</a>
-<a class="sourceLine" id="cb217-15" data-line-number="15">       <span class="kw">then</span> <span class="kw">let</span> check <span class="fu">=</span> checkPassword user password</a>
-<a class="sourceLine" id="cb217-16" data-line-number="16">            <span class="kw">in</span> <span class="dt">Logger</span> (getLog validation <span class="fu">++</span> getLog check) (getVal check)</a>
-<a class="sourceLine" id="cb217-17" data-line-number="17">       <span class="kw">else</span> validation</a></code></pre></div>
-<div class="sourceCode" id="cb218"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb218-1" data-line-number="1">login <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;muad&#39;dib&quot;</span></a>
-<a class="sourceLine" id="cb218-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Valid user&quot;</span>,<span class="st">&quot;Password ok&quot;</span>] <span class="dt">True</span></a>
-<a class="sourceLine" id="cb218-3" data-line-number="3">login <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;arrakis&quot;</span></a>
-<a class="sourceLine" id="cb218-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Valid user&quot;</span>,<span class="st">&quot;Password wrong: arrakis&quot;</span>] <span class="dt">False</span></a>
-<a class="sourceLine" id="cb218-5" data-line-number="5">login <span class="st">&quot;ninja&quot;</span> <span class="st">&quot;&quot;</span></a>
-<a class="sourceLine" id="cb218-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Password ok&quot;</span>] <span class="dt">True</span></a>
-<a class="sourceLine" id="cb218-7" data-line-number="7">login <span class="st">&quot;leto.atreides&quot;</span> <span class="st">&quot;paul&quot;</span></a>
-<a class="sourceLine" id="cb218-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Invalid user: leto.atreides&quot;</span>] <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb217"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb217-1" title="1"><span class="ot">validateUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb217-2" title="2">validateUser <span class="st">&quot;paul.atreides&quot;</span> <span class="fu">=</span> annotate <span class="st">&quot;Valid user&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb217-3" title="3">validateUser <span class="st">&quot;ninja&quot;</span> <span class="fu">=</span> nomsg <span class="dt">True</span></a>
+<a class="sourceLine" id="cb217-4" title="4">validateUser u <span class="fu">=</span> annotate (<span class="st">&quot;Invalid user: &quot;</span><span class="fu">++</span>u) <span class="dt">False</span></a>
+<a class="sourceLine" id="cb217-5" title="5"></a>
+<a class="sourceLine" id="cb217-6" title="6"><span class="ot">checkPassword ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb217-7" title="7">checkPassword <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;muad&#39;dib&quot;</span> <span class="fu">=</span> annotate <span class="st">&quot;Password ok&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb217-8" title="8">checkPassword <span class="st">&quot;ninja&quot;</span>         <span class="st">&quot;&quot;</span>         <span class="fu">=</span> annotate <span class="st">&quot;Password ok&quot;</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb217-9" title="9">checkPassword _               pass       <span class="fu">=</span> annotate (<span class="st">&quot;Password wrong: &quot;</span><span class="fu">++</span>pass) <span class="dt">False</span></a>
+<a class="sourceLine" id="cb217-10" title="10"></a>
+<a class="sourceLine" id="cb217-11" title="11"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb217-12" title="12">login user password <span class="fu">=</span></a>
+<a class="sourceLine" id="cb217-13" title="13">  <span class="kw">let</span> validation <span class="fu">=</span> validateUser user</a>
+<a class="sourceLine" id="cb217-14" title="14">  <span class="kw">in</span> <span class="kw">if</span> (getVal validation)</a>
+<a class="sourceLine" id="cb217-15" title="15">       <span class="kw">then</span> <span class="kw">let</span> check <span class="fu">=</span> checkPassword user password</a>
+<a class="sourceLine" id="cb217-16" title="16">            <span class="kw">in</span> <span class="dt">Logger</span> (getLog validation <span class="fu">++</span> getLog check) (getVal check)</a>
+<a class="sourceLine" id="cb217-17" title="17">       <span class="kw">else</span> validation</a></code></pre></div>
+<div class="sourceCode" id="cb218"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb218-1" title="1">login <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;muad&#39;dib&quot;</span></a>
+<a class="sourceLine" id="cb218-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Valid user&quot;</span>,<span class="st">&quot;Password ok&quot;</span>] <span class="dt">True</span></a>
+<a class="sourceLine" id="cb218-3" title="3">login <span class="st">&quot;paul.atreides&quot;</span> <span class="st">&quot;arrakis&quot;</span></a>
+<a class="sourceLine" id="cb218-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Valid user&quot;</span>,<span class="st">&quot;Password wrong: arrakis&quot;</span>] <span class="dt">False</span></a>
+<a class="sourceLine" id="cb218-5" title="5">login <span class="st">&quot;ninja&quot;</span> <span class="st">&quot;&quot;</span></a>
+<a class="sourceLine" id="cb218-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Password ok&quot;</span>] <span class="dt">True</span></a>
+<a class="sourceLine" id="cb218-7" title="7">login <span class="st">&quot;leto.atreides&quot;</span> <span class="st">&quot;paul&quot;</span></a>
+<a class="sourceLine" id="cb218-8" title="8">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;Invalid user: leto.atreides&quot;</span>] <span class="dt">False</span></a></code></pre></div>
 <p>Let’s try to streamline this code by defining a chaining operator for <code>Logger</code>. The important thing when doing multiple <code>Logger</code> operations is to preserve all the logs. Here’s a chaining operator, <code>#&gt;</code>, and an example of how it can be used to log some arithmetic computations.</p>
-<div class="sourceCode" id="cb219"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb219-1" data-line-number="1"><span class="ot">(#&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b) <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
-<a class="sourceLine" id="cb219-2" data-line-number="2"><span class="dt">Logger</span> la a <span class="fu">#&gt;</span> f <span class="fu">=</span> <span class="kw">let</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> f a  <span class="co">-- feed value to next step</span></a>
-<a class="sourceLine" id="cb219-3" data-line-number="3">                   <span class="kw">in</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b   <span class="co">-- bundle result with all messages</span></a></code></pre></div>
-<div class="sourceCode" id="cb220"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb220-1" data-line-number="1"><span class="co">-- square a number and log a message about it</span></a>
-<a class="sourceLine" id="cb220-2" data-line-number="2"><span class="ot">square ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb220-3" data-line-number="3">square val <span class="fu">=</span> annotate (show val <span class="fu">++</span> <span class="st">&quot;^2&quot;</span>) (val<span class="fu">^</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb220-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb220-5" data-line-number="5"><span class="co">-- add 1 to a number and log a message about it</span></a>
-<a class="sourceLine" id="cb220-6" data-line-number="6"><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb220-7" data-line-number="7">add val <span class="fu">=</span> annotate (show val <span class="fu">++</span> <span class="st">&quot;+1&quot;</span>) (val<span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb220-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb220-9" data-line-number="9"><span class="co">-- double a number and log a message about it</span></a>
-<a class="sourceLine" id="cb220-10" data-line-number="10"><span class="ot">double ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb220-11" data-line-number="11">double val <span class="fu">=</span> annotate (show val <span class="fu">++</span> <span class="st">&quot;*2&quot;</span>) (val<span class="fu">*</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb220-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb220-13" data-line-number="13"><span class="co">-- compute the expression 2*(x^2+1) with logging</span></a>
-<a class="sourceLine" id="cb220-14" data-line-number="14"><span class="ot">compute ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb220-15" data-line-number="15">compute x <span class="fu">=</span></a>
-<a class="sourceLine" id="cb220-16" data-line-number="16">    square x</a>
-<a class="sourceLine" id="cb220-17" data-line-number="17">    <span class="fu">#&gt;</span> add</a>
-<a class="sourceLine" id="cb220-18" data-line-number="18">    <span class="fu">#&gt;</span> double</a></code></pre></div>
-<div class="sourceCode" id="cb221"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb221-1" data-line-number="1">compute <span class="dv">3</span></a>
-<a class="sourceLine" id="cb221-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;3^2&quot;</span>,<span class="st">&quot;9+1&quot;</span>,<span class="st">&quot;10*2&quot;</span>] <span class="dv">20</span></a></code></pre></div>
+<div class="sourceCode" id="cb219"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb219-1" title="1"><span class="ot">(#&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b) <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
+<a class="sourceLine" id="cb219-2" title="2"><span class="dt">Logger</span> la a <span class="fu">#&gt;</span> f <span class="fu">=</span> <span class="kw">let</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> f a  <span class="co">-- feed value to next step</span></a>
+<a class="sourceLine" id="cb219-3" title="3">                   <span class="kw">in</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b   <span class="co">-- bundle result with all messages</span></a></code></pre></div>
+<div class="sourceCode" id="cb220"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb220-1" title="1"><span class="co">-- square a number and log a message about it</span></a>
+<a class="sourceLine" id="cb220-2" title="2"><span class="ot">square ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb220-3" title="3">square val <span class="fu">=</span> annotate (<span class="fu">show</span> val <span class="fu">++</span> <span class="st">&quot;^2&quot;</span>) (val<span class="fu">^</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb220-4" title="4"></a>
+<a class="sourceLine" id="cb220-5" title="5"><span class="co">-- add 1 to a number and log a message about it</span></a>
+<a class="sourceLine" id="cb220-6" title="6"><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb220-7" title="7">add val <span class="fu">=</span> annotate (<span class="fu">show</span> val <span class="fu">++</span> <span class="st">&quot;+1&quot;</span>) (val<span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb220-8" title="8"></a>
+<a class="sourceLine" id="cb220-9" title="9"><span class="co">-- double a number and log a message about it</span></a>
+<a class="sourceLine" id="cb220-10" title="10"><span class="ot">double ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb220-11" title="11">double val <span class="fu">=</span> annotate (<span class="fu">show</span> val <span class="fu">++</span> <span class="st">&quot;*2&quot;</span>) (val<span class="fu">*</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb220-12" title="12"></a>
+<a class="sourceLine" id="cb220-13" title="13"><span class="co">-- compute the expression 2*(x^2+1) with logging</span></a>
+<a class="sourceLine" id="cb220-14" title="14"><span class="ot">compute ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb220-15" title="15">compute x <span class="fu">=</span></a>
+<a class="sourceLine" id="cb220-16" title="16">    square x</a>
+<a class="sourceLine" id="cb220-17" title="17">    <span class="fu">#&gt;</span> add</a>
+<a class="sourceLine" id="cb220-18" title="18">    <span class="fu">#&gt;</span> double</a></code></pre></div>
+<div class="sourceCode" id="cb221"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb221-1" title="1">compute <span class="dv">3</span></a>
+<a class="sourceLine" id="cb221-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;3^2&quot;</span>,<span class="st">&quot;9+1&quot;</span>,<span class="st">&quot;10*2&quot;</span>] <span class="dv">20</span></a></code></pre></div>
 <p>We can streamline <code>login</code> quite a bit by using <code>#&gt;</code>. Note how we don’t need to worry about combining logs together. Also note how we use a lambda expression instead of defining a helper function.</p>
-<div class="sourceCode" id="cb222"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb222-1" data-line-number="1"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb222-2" data-line-number="2">login user password <span class="fu">=</span></a>
-<a class="sourceLine" id="cb222-3" data-line-number="3">  validateUser user</a>
-<a class="sourceLine" id="cb222-4" data-line-number="4">  <span class="fu">#&gt;</span></a>
-<a class="sourceLine" id="cb222-5" data-line-number="5">  \valid <span class="ot">-&gt;</span> <span class="kw">if</span> valid <span class="kw">then</span> checkPassword user password</a>
-<a class="sourceLine" id="cb222-6" data-line-number="6">                     <span class="kw">else</span> nomsg <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb222"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb222-1" title="1"><span class="ot">login ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb222-2" title="2">login user password <span class="fu">=</span></a>
+<a class="sourceLine" id="cb222-3" title="3">  validateUser user</a>
+<a class="sourceLine" id="cb222-4" title="4">  <span class="fu">#&gt;</span></a>
+<a class="sourceLine" id="cb222-5" title="5">  \valid <span class="ot">-&gt;</span> <span class="kw">if</span> valid <span class="kw">then</span> checkPassword user password</a>
+<a class="sourceLine" id="cb222-6" title="6">                     <span class="kw">else</span> nomsg <span class="dt">False</span></a></code></pre></div>
 <p>To ramp things up a bit, let’s use <code>Logger</code> in a recursive list processing function. Here’s a logging version of <code>filter</code>. Note how the code chains a log message before the recursive call in order to keep the order of log entries nice.</p>
-<div class="sourceCode" id="cb223"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb223-1" data-line-number="1"><span class="co">-- sometimes you don&#39;t need the previous value:</span></a>
-<a class="sourceLine" id="cb223-2" data-line-number="2"><span class="ot">(##&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
-<a class="sourceLine" id="cb223-3" data-line-number="3"><span class="dt">Logger</span> la _ <span class="fu">##&gt;</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b</a>
-<a class="sourceLine" id="cb223-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb223-5" data-line-number="5"><span class="ot">filterLog ::</span> (<span class="dt">Eq</span> a, <span class="dt">Show</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> [a]</a>
-<a class="sourceLine" id="cb223-6" data-line-number="6">filterLog f [] <span class="fu">=</span> nomsg []</a>
-<a class="sourceLine" id="cb223-7" data-line-number="7">filterLog f (x<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb223-8" data-line-number="8">   <span class="fu">|</span> f x       <span class="fu">=</span> msg (<span class="st">&quot;keeping &quot;</span><span class="fu">++</span>show x) <span class="fu">##&gt;</span> filterLog f xs <span class="fu">#&gt;</span> (\xs&#39; <span class="ot">-&gt;</span> nomsg (x<span class="fu">:</span>xs&#39;))</a>
-<a class="sourceLine" id="cb223-9" data-line-number="9">   <span class="fu">|</span> otherwise <span class="fu">=</span> msg (<span class="st">&quot;dropping &quot;</span><span class="fu">++</span>show x) <span class="fu">##&gt;</span> filterLog f xs</a></code></pre></div>
-<div class="sourceCode" id="cb224"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb224-1" data-line-number="1">filterLog (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb224-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;keeping 1&quot;</span>,<span class="st">&quot;dropping -2&quot;</span>,<span class="st">&quot;keeping 3&quot;</span>,<span class="st">&quot;dropping -4&quot;</span>,<span class="st">&quot;dropping 0&quot;</span>] [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb223"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb223-1" title="1"><span class="co">-- sometimes you don&#39;t need the previous value:</span></a>
+<a class="sourceLine" id="cb223-2" title="2"><span class="ot">(##&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
+<a class="sourceLine" id="cb223-3" title="3"><span class="dt">Logger</span> la _ <span class="fu">##&gt;</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b</a>
+<a class="sourceLine" id="cb223-4" title="4"></a>
+<a class="sourceLine" id="cb223-5" title="5"><span class="ot">filterLog ::</span> (<span class="dt">Eq</span> a, <span class="dt">Show</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> [a]</a>
+<a class="sourceLine" id="cb223-6" title="6">filterLog f [] <span class="fu">=</span> nomsg []</a>
+<a class="sourceLine" id="cb223-7" title="7">filterLog f (x<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb223-8" title="8">   <span class="fu">|</span> f x       <span class="fu">=</span> msg (<span class="st">&quot;keeping &quot;</span><span class="fu">++show</span> x) <span class="fu">##&gt;</span> filterLog f xs <span class="fu">#&gt;</span> (\xs&#39; <span class="ot">-&gt;</span> nomsg (x<span class="fu">:</span>xs&#39;))</a>
+<a class="sourceLine" id="cb223-9" title="9">   <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> msg (<span class="st">&quot;dropping &quot;</span><span class="fu">++show</span> x) <span class="fu">##&gt;</span> filterLog f xs</a></code></pre></div>
+<div class="sourceCode" id="cb224"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb224-1" title="1">filterLog (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb224-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;keeping 1&quot;</span>,<span class="st">&quot;dropping -2&quot;</span>,<span class="st">&quot;keeping 3&quot;</span>,<span class="st">&quot;dropping -4&quot;</span>,<span class="st">&quot;dropping 0&quot;</span>] [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
 <h2 id="example-3-keeping-state"><span class="header-section-number">13.3</span> Example 3: Keeping State</h2>
 <p>In the previous example we just wrote some state (the log). Sometimes we need computations that change some sort of shared state. Let’s look at accounts in a small bank. We’ll first define a datatype for the state of the bank: the balances of all accounts, as a map from account name to balance.</p>
-<div class="sourceCode" id="cb225"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb225-1" data-line-number="1"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a>
-<a class="sourceLine" id="cb225-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb225-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Bank</span> <span class="fu">=</span> <span class="dt">Bank</span> (<span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span>)</a>
-<a class="sourceLine" id="cb225-4" data-line-number="4">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
+<div class="sourceCode" id="cb225"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb225-1" title="1"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></a>
+<a class="sourceLine" id="cb225-2" title="2"></a>
+<a class="sourceLine" id="cb225-3" title="3"><span class="kw">data</span> <span class="dt">Bank</span> <span class="fu">=</span> <span class="dt">Bank</span> (<span class="dt">Map.Map</span> <span class="dt">String</span> <span class="dt">Int</span>)</a>
+<a class="sourceLine" id="cb225-4" title="4">  <span class="kw">deriving</span> <span class="dt">Show</span></a></code></pre></div>
 <p>Here’s how we can deposit some money to an account. We use the function <code>adjust</code> from <code>Data.Map</code> to modify the map.</p>
-<div class="sourceCode" id="cb226"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb226-1" data-line-number="1"><span class="co">-- Apply a function to one value in a map</span></a>
-<a class="sourceLine" id="cb226-2" data-line-number="2">Map.adjust<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a></code></pre></div>
-<div class="sourceCode" id="cb227"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb227-1" data-line-number="1"><span class="ot">deposit ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
-<a class="sourceLine" id="cb227-2" data-line-number="2">deposit accountName amount (<span class="dt">Bank</span> accounts) <span class="fu">=</span></a>
-<a class="sourceLine" id="cb227-3" data-line-number="3">  <span class="dt">Bank</span> (Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">+</span>amount) accountName accounts)</a></code></pre></div>
+<div class="sourceCode" id="cb226"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb226-1" title="1"><span class="co">-- Apply a function to one value in a map</span></a>
+<a class="sourceLine" id="cb226-2" title="2">Map.adjust<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> a) <span class="ot">-&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a</a></code></pre></div>
+<div class="sourceCode" id="cb227"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb227-1" title="1"><span class="ot">deposit ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
+<a class="sourceLine" id="cb227-2" title="2">deposit accountName amount (<span class="dt">Bank</span> accounts) <span class="fu">=</span></a>
+<a class="sourceLine" id="cb227-3" title="3">  <span class="dt">Bank</span> (Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">+</span>amount) accountName accounts)</a></code></pre></div>
 <p>Withdrawing money is a bit more complicated, since we want to handle some special cases like the account not existing, or the account not having enough money. We use the library function <code>findWithDefault</code> to help us along.</p>
-<div class="sourceCode" id="cb228"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb228-1" data-line-number="1"><span class="co">-- Fetch the value corresponding to a key from a map,</span></a>
-<a class="sourceLine" id="cb228-2" data-line-number="2"><span class="co">-- or a default value in case the key does not exist</span></a>
-<a class="sourceLine" id="cb228-3" data-line-number="3">Map.findWithDefault<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> a</a></code></pre></div>
-<div class="sourceCode" id="cb229"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb229-1" data-line-number="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (<span class="dt">Int</span>,<span class="dt">Bank</span>)</a>
-<a class="sourceLine" id="cb229-2" data-line-number="2">withdraw accountName amount (<span class="dt">Bank</span> accounts) <span class="fu">=</span></a>
-<a class="sourceLine" id="cb229-3" data-line-number="3">  <span class="kw">let</span> <span class="co">-- balance is 0 for a nonexistant account</span></a>
-<a class="sourceLine" id="cb229-4" data-line-number="4">      balance <span class="fu">=</span> Map.findWithDefault <span class="dv">0</span> accountName accounts</a>
-<a class="sourceLine" id="cb229-5" data-line-number="5">      <span class="co">-- can&#39;t withdraw over balance</span></a>
-<a class="sourceLine" id="cb229-6" data-line-number="6">      withdrawal <span class="fu">=</span> min amount balance</a>
-<a class="sourceLine" id="cb229-7" data-line-number="7">      newAccounts <span class="fu">=</span> Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">-</span>withdrawal) accountName accounts</a>
-<a class="sourceLine" id="cb229-8" data-line-number="8">  <span class="kw">in</span> (withdrawal, <span class="dt">Bank</span> newAccounts)</a></code></pre></div>
+<div class="sourceCode" id="cb228"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb228-1" title="1"><span class="co">-- Fetch the value corresponding to a key from a map,</span></a>
+<a class="sourceLine" id="cb228-2" title="2"><span class="co">-- or a default value in case the key does not exist</span></a>
+<a class="sourceLine" id="cb228-3" title="3">Map.findWithDefault<span class="ot"> ::</span> <span class="dt">Ord</span> k <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Map.Map</span> k a <span class="ot">-&gt;</span> a</a></code></pre></div>
+<div class="sourceCode" id="cb229"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb229-1" title="1"><span class="ot">withdraw ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (<span class="dt">Int</span>,<span class="dt">Bank</span>)</a>
+<a class="sourceLine" id="cb229-2" title="2">withdraw accountName amount (<span class="dt">Bank</span> accounts) <span class="fu">=</span></a>
+<a class="sourceLine" id="cb229-3" title="3">  <span class="kw">let</span> <span class="co">-- balance is 0 for a nonexistant account</span></a>
+<a class="sourceLine" id="cb229-4" title="4">      balance <span class="fu">=</span> Map.findWithDefault <span class="dv">0</span> accountName accounts</a>
+<a class="sourceLine" id="cb229-5" title="5">      <span class="co">-- can&#39;t withdraw over balance</span></a>
+<a class="sourceLine" id="cb229-6" title="6">      withdrawal <span class="fu">=</span> <span class="fu">min</span> amount balance</a>
+<a class="sourceLine" id="cb229-7" title="7">      newAccounts <span class="fu">=</span> Map.adjust (\x <span class="ot">-&gt;</span> x<span class="fu">-</span>withdrawal) accountName accounts</a>
+<a class="sourceLine" id="cb229-8" title="8">  <span class="kw">in</span> (withdrawal, <span class="dt">Bank</span> newAccounts)</a></code></pre></div>
 <p>Finally, let’s write a function that takes at most 100 money from one account, splits the money in half, and deposits it in two accounts. Pay attention to how we need to carefully thread the different versions of the bank, <code>bank</code>, <code>bank1</code>, <code>bank2</code> and <code>bank3</code> to make sure all transactions happen in the right order.</p>
-<div class="sourceCode" id="cb230"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb230-1" data-line-number="1"><span class="ot">share ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
-<a class="sourceLine" id="cb230-2" data-line-number="2">share from to1 to2 bank <span class="fu">=</span></a>
-<a class="sourceLine" id="cb230-3" data-line-number="3">  <span class="kw">let</span> (amount,bank1) <span class="fu">=</span> withdraw from <span class="dv">100</span> bank</a>
-<a class="sourceLine" id="cb230-4" data-line-number="4">      half <span class="fu">=</span> div amount <span class="dv">2</span></a>
-<a class="sourceLine" id="cb230-5" data-line-number="5">      <span class="co">-- carefully preserve all money, even if amount was an odd number</span></a>
-<a class="sourceLine" id="cb230-6" data-line-number="6">      rest <span class="fu">=</span> amount<span class="fu">-</span>half</a>
-<a class="sourceLine" id="cb230-7" data-line-number="7">      bank2 <span class="fu">=</span> deposit to1 half bank1</a>
-<a class="sourceLine" id="cb230-8" data-line-number="8">      bank3 <span class="fu">=</span> deposit to2 rest bank2</a>
-<a class="sourceLine" id="cb230-9" data-line-number="9">  <span class="kw">in</span> bank3</a></code></pre></div>
-<div class="sourceCode" id="cb231"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb231-1" data-line-number="1">share <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span></a>
-<a class="sourceLine" id="cb231-2" data-line-number="2">      (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">1000</span>)]))</a>
-<a class="sourceLine" id="cb231-3" data-line-number="3">   <span class="fu">==&gt;</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">900</span>)])</a>
-<a class="sourceLine" id="cb231-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb231-5" data-line-number="5">share <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span></a>
-<a class="sourceLine" id="cb231-6" data-line-number="6">      (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">91</span>)]))</a>
-<a class="sourceLine" id="cb231-7" data-line-number="7">   <span class="fu">==&gt;</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">46</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">45</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">0</span>)])</a></code></pre></div>
+<div class="sourceCode" id="cb230"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb230-1" title="1"><span class="ot">share ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> <span class="dt">Bank</span></a>
+<a class="sourceLine" id="cb230-2" title="2">share from to1 to2 bank <span class="fu">=</span></a>
+<a class="sourceLine" id="cb230-3" title="3">  <span class="kw">let</span> (amount,bank1) <span class="fu">=</span> withdraw from <span class="dv">100</span> bank</a>
+<a class="sourceLine" id="cb230-4" title="4">      half <span class="fu">=</span> <span class="fu">div</span> amount <span class="dv">2</span></a>
+<a class="sourceLine" id="cb230-5" title="5">      <span class="co">-- carefully preserve all money, even if amount was an odd number</span></a>
+<a class="sourceLine" id="cb230-6" title="6">      rest <span class="fu">=</span> amount<span class="fu">-</span>half</a>
+<a class="sourceLine" id="cb230-7" title="7">      bank2 <span class="fu">=</span> deposit to1 half bank1</a>
+<a class="sourceLine" id="cb230-8" title="8">      bank3 <span class="fu">=</span> deposit to2 rest bank2</a>
+<a class="sourceLine" id="cb230-9" title="9">  <span class="kw">in</span> bank3</a></code></pre></div>
+<div class="sourceCode" id="cb231"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb231-1" title="1">share <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span></a>
+<a class="sourceLine" id="cb231-2" title="2">      (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">1000</span>)]))</a>
+<a class="sourceLine" id="cb231-3" title="3">   <span class="fu">==&gt;</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">900</span>)])</a>
+<a class="sourceLine" id="cb231-4" title="4"></a>
+<a class="sourceLine" id="cb231-5" title="5">share <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span></a>
+<a class="sourceLine" id="cb231-6" title="6">      (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">91</span>)]))</a>
+<a class="sourceLine" id="cb231-7" title="7">   <span class="fu">==&gt;</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">46</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">45</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">0</span>)])</a></code></pre></div>
 <p>Code like this turns up often in Haskell when you’re doing serial updates to one value, while also performing some other computations on the side. It’s easy to make a mistake, and the type system won’t help you if you e.g. reuse the <code>bank1</code> value. Let’s rewrite <code>share</code> so that we don’t need to refer to the bank itself. We can again use the same chaining idea to accomplish this.</p>
-<div class="sourceCode" id="cb232"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb232-1" data-line-number="1"><span class="co">-- `BankOp a` is an operation that transforms a Bank value,</span></a>
-<a class="sourceLine" id="cb232-2" data-line-number="2"><span class="co">-- while returning a value of type `a`</span></a>
-<a class="sourceLine" id="cb232-3" data-line-number="3"><span class="kw">data</span> <span class="dt">BankOp</span> a <span class="fu">=</span> <span class="dt">BankOp</span> (<span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>))</a>
-<a class="sourceLine" id="cb232-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb232-5" data-line-number="5"><span class="co">-- running a BankOp on a Bank</span></a>
-<a class="sourceLine" id="cb232-6" data-line-number="6"><span class="ot">runBankOp ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>)</a>
-<a class="sourceLine" id="cb232-7" data-line-number="7">runBankOp (<span class="dt">BankOp</span> f) bank <span class="fu">=</span> f bank</a>
-<a class="sourceLine" id="cb232-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb232-9" data-line-number="9"><span class="co">-- Running one BankOp after another</span></a>
-<a class="sourceLine" id="cb232-10" data-line-number="10"><span class="ot">(+&gt;&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a>
-<a class="sourceLine" id="cb232-11" data-line-number="11">op1 <span class="fu">+&gt;&gt;</span> op2 <span class="fu">=</span> <span class="dt">BankOp</span> combined</a>
-<a class="sourceLine" id="cb232-12" data-line-number="12">  <span class="kw">where</span> combined bank <span class="fu">=</span> <span class="kw">let</span> (_,bank1) <span class="fu">=</span> runBankOp op1 bank</a>
-<a class="sourceLine" id="cb232-13" data-line-number="13">                        <span class="kw">in</span> runBankOp op2 bank1</a>
-<a class="sourceLine" id="cb232-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb232-15" data-line-number="15"><span class="co">-- Running a parameterized BankOp, using the value returned</span></a>
-<a class="sourceLine" id="cb232-16" data-line-number="16"><span class="co">-- by a previous BankOp.  The implementation is a bit tricky</span></a>
-<a class="sourceLine" id="cb232-17" data-line-number="17"><span class="co">-- but it&#39;s enough to understand how +&gt; is used for now.</span></a>
-<a class="sourceLine" id="cb232-18" data-line-number="18"><span class="ot">(+&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b) <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a>
-<a class="sourceLine" id="cb232-19" data-line-number="19">op <span class="fu">+&gt;</span> parameterized <span class="fu">=</span> <span class="dt">BankOp</span> combined</a>
-<a class="sourceLine" id="cb232-20" data-line-number="20">  <span class="kw">where</span> combined bank <span class="fu">=</span> <span class="kw">let</span> (a,bank1) <span class="fu">=</span> runBankOp op bank</a>
-<a class="sourceLine" id="cb232-21" data-line-number="21">                        <span class="kw">in</span> runBankOp (parameterized a) bank1</a>
-<a class="sourceLine" id="cb232-22" data-line-number="22"></a>
-<a class="sourceLine" id="cb232-23" data-line-number="23"><span class="co">-- Make a BankOp out of deposit.</span></a>
-<a class="sourceLine" id="cb232-24" data-line-number="24"><span class="co">-- There is no return value so we use ().</span></a>
-<a class="sourceLine" id="cb232-25" data-line-number="25"><span class="ot">depositOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
-<a class="sourceLine" id="cb232-26" data-line-number="26">depositOp accountName amount <span class="fu">=</span> <span class="dt">BankOp</span> depositHelper</a>
-<a class="sourceLine" id="cb232-27" data-line-number="27">  <span class="kw">where</span> depositHelper bank <span class="fu">=</span> ((), deposit accountName amount bank)</a>
-<a class="sourceLine" id="cb232-28" data-line-number="28"></a>
-<a class="sourceLine" id="cb232-29" data-line-number="29"><span class="co">-- Make a BankOp out of withdraw. Note how</span></a>
-<a class="sourceLine" id="cb232-30" data-line-number="30"><span class="co">--   withdraw accountName amount :: Bank -&gt; (Int,Bank)</span></a>
-<a class="sourceLine" id="cb232-31" data-line-number="31"><span class="co">-- is almost a BankOp already!</span></a>
-<a class="sourceLine" id="cb232-32" data-line-number="32"><span class="ot">withdrawOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb232-33" data-line-number="33">withdrawOp accountName amount <span class="fu">=</span> <span class="dt">BankOp</span> (withdraw accountName amount)</a></code></pre></div>
+<div class="sourceCode" id="cb232"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb232-1" title="1"><span class="co">-- `BankOp a` is an operation that transforms a Bank value,</span></a>
+<a class="sourceLine" id="cb232-2" title="2"><span class="co">-- while returning a value of type `a`</span></a>
+<a class="sourceLine" id="cb232-3" title="3"><span class="kw">data</span> <span class="dt">BankOp</span> a <span class="fu">=</span> <span class="dt">BankOp</span> (<span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>))</a>
+<a class="sourceLine" id="cb232-4" title="4"></a>
+<a class="sourceLine" id="cb232-5" title="5"><span class="co">-- running a BankOp on a Bank</span></a>
+<a class="sourceLine" id="cb232-6" title="6"><span class="ot">runBankOp ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">Bank</span> <span class="ot">-&gt;</span> (a,<span class="dt">Bank</span>)</a>
+<a class="sourceLine" id="cb232-7" title="7">runBankOp (<span class="dt">BankOp</span> f) bank <span class="fu">=</span> f bank</a>
+<a class="sourceLine" id="cb232-8" title="8"></a>
+<a class="sourceLine" id="cb232-9" title="9"><span class="co">-- Running one BankOp after another</span></a>
+<a class="sourceLine" id="cb232-10" title="10"><span class="ot">(+&gt;&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a>
+<a class="sourceLine" id="cb232-11" title="11">op1 <span class="fu">+&gt;&gt;</span> op2 <span class="fu">=</span> <span class="dt">BankOp</span> combined</a>
+<a class="sourceLine" id="cb232-12" title="12">  <span class="kw">where</span> combined bank <span class="fu">=</span> <span class="kw">let</span> (_,bank1) <span class="fu">=</span> runBankOp op1 bank</a>
+<a class="sourceLine" id="cb232-13" title="13">                        <span class="kw">in</span> runBankOp op2 bank1</a>
+<a class="sourceLine" id="cb232-14" title="14"></a>
+<a class="sourceLine" id="cb232-15" title="15"><span class="co">-- Running a parameterized BankOp, using the value returned</span></a>
+<a class="sourceLine" id="cb232-16" title="16"><span class="co">-- by a previous BankOp.  The implementation is a bit tricky</span></a>
+<a class="sourceLine" id="cb232-17" title="17"><span class="co">-- but it&#39;s enough to understand how +&gt; is used for now.</span></a>
+<a class="sourceLine" id="cb232-18" title="18"><span class="ot">(+&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b) <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a>
+<a class="sourceLine" id="cb232-19" title="19">op <span class="fu">+&gt;</span> parameterized <span class="fu">=</span> <span class="dt">BankOp</span> combined</a>
+<a class="sourceLine" id="cb232-20" title="20">  <span class="kw">where</span> combined bank <span class="fu">=</span> <span class="kw">let</span> (a,bank1) <span class="fu">=</span> runBankOp op bank</a>
+<a class="sourceLine" id="cb232-21" title="21">                        <span class="kw">in</span> runBankOp (parameterized a) bank1</a>
+<a class="sourceLine" id="cb232-22" title="22"></a>
+<a class="sourceLine" id="cb232-23" title="23"><span class="co">-- Make a BankOp out of deposit.</span></a>
+<a class="sourceLine" id="cb232-24" title="24"><span class="co">-- There is no return value so we use ().</span></a>
+<a class="sourceLine" id="cb232-25" title="25"><span class="ot">depositOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
+<a class="sourceLine" id="cb232-26" title="26">depositOp accountName amount <span class="fu">=</span> <span class="dt">BankOp</span> depositHelper</a>
+<a class="sourceLine" id="cb232-27" title="27">  <span class="kw">where</span> depositHelper bank <span class="fu">=</span> ((), deposit accountName amount bank)</a>
+<a class="sourceLine" id="cb232-28" title="28"></a>
+<a class="sourceLine" id="cb232-29" title="29"><span class="co">-- Make a BankOp out of withdraw. Note how</span></a>
+<a class="sourceLine" id="cb232-30" title="30"><span class="co">--   withdraw accountName amount :: Bank -&gt; (Int,Bank)</span></a>
+<a class="sourceLine" id="cb232-31" title="31"><span class="co">-- is almost a BankOp already!</span></a>
+<a class="sourceLine" id="cb232-32" title="32"><span class="ot">withdrawOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb232-33" title="33">withdrawOp accountName amount <span class="fu">=</span> <span class="dt">BankOp</span> (withdraw accountName amount)</a></code></pre></div>
 <p>Let’s see how chaining works with these bank operations.</p>
-<div class="sourceCode" id="cb233"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb233-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> bank <span class="fu">=</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">10</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">50</span>)])</a>
-<a class="sourceLine" id="cb233-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb233-3" data-line-number="3"><span class="co">-- Running a number of operations using +&gt;&gt;</span></a>
-<a class="sourceLine" id="cb233-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb233-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span>) bank</a>
-<a class="sourceLine" id="cb233-6" data-line-number="6">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">11</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">50</span>)]))</a>
-<a class="sourceLine" id="cb233-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb233-8" data-line-number="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> depositOp <span class="st">&quot;grace&quot;</span> <span class="dv">1</span>) bank</a>
-<a class="sourceLine" id="cb233-9" data-line-number="9">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">11</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">51</span>)]))</a>
-<a class="sourceLine" id="cb233-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb233-11" data-line-number="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> depositOp <span class="st">&quot;grace&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">11</span>) bank</a>
-<a class="sourceLine" id="cb233-12" data-line-number="12">(<span class="dv">11</span>,<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">51</span>)]))</a>
-<a class="sourceLine" id="cb233-13" data-line-number="13"></a>
-<a class="sourceLine" id="cb233-14" data-line-number="14"><span class="co">-- Using +&gt; to implement a transfer from one account to the other:</span></a>
-<a class="sourceLine" id="cb233-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb233-16" data-line-number="16"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">5</span> <span class="fu">+&gt;</span> depositOp <span class="st">&quot;grace&quot;</span>) bank</a>
-<a class="sourceLine" id="cb233-17" data-line-number="17">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">5</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">55</span>)]))</a>
-<a class="sourceLine" id="cb233-18" data-line-number="18"></a>
-<a class="sourceLine" id="cb233-19" data-line-number="19"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">100</span> <span class="fu">+&gt;</span> depositOp <span class="st">&quot;grace&quot;</span>) bank</a>
-<a class="sourceLine" id="cb233-20" data-line-number="20">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">60</span>)]))</a></code></pre></div>
+<div class="sourceCode" id="cb233"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb233-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">let</span> bank <span class="fu">=</span> <span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">10</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">50</span>)])</a>
+<a class="sourceLine" id="cb233-2" title="2"></a>
+<a class="sourceLine" id="cb233-3" title="3"><span class="co">-- Running a number of operations using +&gt;&gt;</span></a>
+<a class="sourceLine" id="cb233-4" title="4"></a>
+<a class="sourceLine" id="cb233-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span>) bank</a>
+<a class="sourceLine" id="cb233-6" title="6">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">11</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">50</span>)]))</a>
+<a class="sourceLine" id="cb233-7" title="7"></a>
+<a class="sourceLine" id="cb233-8" title="8"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> depositOp <span class="st">&quot;grace&quot;</span> <span class="dv">1</span>) bank</a>
+<a class="sourceLine" id="cb233-9" title="9">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">11</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">51</span>)]))</a>
+<a class="sourceLine" id="cb233-10" title="10"></a>
+<a class="sourceLine" id="cb233-11" title="11"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (depositOp <span class="st">&quot;edsger&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> depositOp <span class="st">&quot;grace&quot;</span> <span class="dv">1</span> <span class="fu">+&gt;&gt;</span> withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">11</span>) bank</a>
+<a class="sourceLine" id="cb233-12" title="12">(<span class="dv">11</span>,<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">51</span>)]))</a>
+<a class="sourceLine" id="cb233-13" title="13"></a>
+<a class="sourceLine" id="cb233-14" title="14"><span class="co">-- Using +&gt; to implement a transfer from one account to the other:</span></a>
+<a class="sourceLine" id="cb233-15" title="15"></a>
+<a class="sourceLine" id="cb233-16" title="16"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">5</span> <span class="fu">+&gt;</span> depositOp <span class="st">&quot;grace&quot;</span>) bank</a>
+<a class="sourceLine" id="cb233-17" title="17">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">5</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">55</span>)]))</a>
+<a class="sourceLine" id="cb233-18" title="18"></a>
+<a class="sourceLine" id="cb233-19" title="19"><span class="dt">Prelude</span><span class="fu">&gt;</span> runBankOp (withdrawOp <span class="st">&quot;edsger&quot;</span> <span class="dv">100</span> <span class="fu">+&gt;</span> depositOp <span class="st">&quot;grace&quot;</span>) bank</a>
+<a class="sourceLine" id="cb233-20" title="20">((),<span class="dt">Bank</span> (fromList [(<span class="st">&quot;edsger&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;grace&quot;</span>,<span class="dv">60</span>)]))</a></code></pre></div>
 <p>Note how a value of type <code>BankOp</code> represents a process that transforms the bank. The initial state of the bank must be supplied using <code>runBankOp</code>. This makes sense because <code>BankOp</code> transformations can be composed, unlike <code>Bank</code> states. Having to use <code>runBankOp</code> makes the distinction between <em>defining</em> operations and <em>executing them</em> clearer.</p>
 <p>Now that we’re familiar with manipulating <code>BankOp</code> values, we can implement <code>share</code> as a <code>BankOp</code>. We implement a helper <code>distributeOp</code> to make the code a bit neater.</p>
-<div class="sourceCode" id="cb234"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb234-1" data-line-number="1"><span class="co">-- distribute amount to two accounts</span></a>
-<a class="sourceLine" id="cb234-2" data-line-number="2"><span class="ot">distributeOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
-<a class="sourceLine" id="cb234-3" data-line-number="3">distributeOp to1 to2 amount <span class="fu">=</span></a>
-<a class="sourceLine" id="cb234-4" data-line-number="4">  depositOp to1 half</a>
-<a class="sourceLine" id="cb234-5" data-line-number="5">  <span class="fu">+&gt;&gt;</span></a>
-<a class="sourceLine" id="cb234-6" data-line-number="6">  depositOp to2 rest</a>
-<a class="sourceLine" id="cb234-7" data-line-number="7">  <span class="kw">where</span> half <span class="fu">=</span> div amount <span class="dv">2</span></a>
-<a class="sourceLine" id="cb234-8" data-line-number="8">        rest <span class="fu">=</span> amount <span class="fu">-</span> half</a>
-<a class="sourceLine" id="cb234-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb234-10" data-line-number="10"><span class="ot">shareOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
-<a class="sourceLine" id="cb234-11" data-line-number="11">shareOp from to1 to2 <span class="fu">=</span></a>
-<a class="sourceLine" id="cb234-12" data-line-number="12">  withdrawOp from <span class="dv">100</span></a>
-<a class="sourceLine" id="cb234-13" data-line-number="13">  <span class="fu">+&gt;</span></a>
-<a class="sourceLine" id="cb234-14" data-line-number="14">  distributeOp to1 to2</a></code></pre></div>
-<div class="sourceCode" id="cb235"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb235-1" data-line-number="1">runBankOp (shareOp <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span>)</a>
-<a class="sourceLine" id="cb235-2" data-line-number="2">          (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">1000</span>)]))</a>
-<a class="sourceLine" id="cb235-3" data-line-number="3">  <span class="fu">==&gt;</span> ((),<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">900</span>)]))</a>
-<a class="sourceLine" id="cb235-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb235-5" data-line-number="5">runBankOp (shareOp <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span>)</a>
-<a class="sourceLine" id="cb235-6" data-line-number="6">          (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">91</span>)]))</a>
-<a class="sourceLine" id="cb235-7" data-line-number="7">  <span class="fu">==&gt;</span> ((),<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">46</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">45</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">0</span>)]))</a></code></pre></div>
+<div class="sourceCode" id="cb234"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb234-1" title="1"><span class="co">-- distribute amount to two accounts</span></a>
+<a class="sourceLine" id="cb234-2" title="2"><span class="ot">distributeOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
+<a class="sourceLine" id="cb234-3" title="3">distributeOp to1 to2 amount <span class="fu">=</span></a>
+<a class="sourceLine" id="cb234-4" title="4">  depositOp to1 half</a>
+<a class="sourceLine" id="cb234-5" title="5">  <span class="fu">+&gt;&gt;</span></a>
+<a class="sourceLine" id="cb234-6" title="6">  depositOp to2 rest</a>
+<a class="sourceLine" id="cb234-7" title="7">  <span class="kw">where</span> half <span class="fu">=</span> <span class="fu">div</span> amount <span class="dv">2</span></a>
+<a class="sourceLine" id="cb234-8" title="8">        rest <span class="fu">=</span> amount <span class="fu">-</span> half</a>
+<a class="sourceLine" id="cb234-9" title="9"></a>
+<a class="sourceLine" id="cb234-10" title="10"><span class="ot">shareOp ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">BankOp</span> ()</a>
+<a class="sourceLine" id="cb234-11" title="11">shareOp from to1 to2 <span class="fu">=</span></a>
+<a class="sourceLine" id="cb234-12" title="12">  withdrawOp from <span class="dv">100</span></a>
+<a class="sourceLine" id="cb234-13" title="13">  <span class="fu">+&gt;</span></a>
+<a class="sourceLine" id="cb234-14" title="14">  distributeOp to1 to2</a></code></pre></div>
+<div class="sourceCode" id="cb235"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb235-1" title="1">runBankOp (shareOp <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span>)</a>
+<a class="sourceLine" id="cb235-2" title="2">          (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">1000</span>)]))</a>
+<a class="sourceLine" id="cb235-3" title="3">  <span class="fu">==&gt;</span> ((),<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">50</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">900</span>)]))</a>
+<a class="sourceLine" id="cb235-4" title="4"></a>
+<a class="sourceLine" id="cb235-5" title="5">runBankOp (shareOp <span class="st">&quot;wotan&quot;</span> <span class="st">&quot;siegfried&quot;</span> <span class="st">&quot;brunhilde&quot;</span>)</a>
+<a class="sourceLine" id="cb235-6" title="6">          (<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">91</span>)]))</a>
+<a class="sourceLine" id="cb235-7" title="7">  <span class="fu">==&gt;</span> ((),<span class="dt">Bank</span> (Map.fromList [(<span class="st">&quot;brunhilde&quot;</span>,<span class="dv">46</span>),(<span class="st">&quot;siegfried&quot;</span>,<span class="dv">45</span>),(<span class="st">&quot;wotan&quot;</span>,<span class="dv">0</span>)]))</a></code></pre></div>
 <p>That was pretty clean wasn’t it? We don’t need to mention the bank at all, we can almost program as if in an imperative language while staying completely pure.</p>
 <p>You can find all of this code in the course repository under <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/Bank.hs"><code>exercises/Examples/Bank.hs</code></a>.</p>
 <h2 id="finally-the-monad-type-class"><span class="header-section-number">13.4</span> Finally: The Monad Type Class</h2>
 <p>We’ve now seen three different types with a chaining operation:</p>
-<div class="sourceCode" id="cb236"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb236-1" data-line-number="1"><span class="ot">(?&gt;) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb236-2" data-line-number="2"><span class="ot">(#&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b) <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
-<a class="sourceLine" id="cb236-3" data-line-number="3"><span class="ot">(+&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b) <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a></code></pre></div>
+<div class="sourceCode" id="cb236"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb236-1" title="1"><span class="ot">(?&gt;) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb236-2" title="2"><span class="ot">(#&gt;) ::</span> <span class="dt">Logger</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Logger</span> b) <span class="ot">-&gt;</span> <span class="dt">Logger</span> b</a>
+<a class="sourceLine" id="cb236-3" title="3"><span class="ot">(+&gt;) ::</span> <span class="dt">BankOp</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b) <span class="ot">-&gt;</span> <span class="dt">BankOp</span> b</a></code></pre></div>
 <p>Just like previously with <code>map</code> and <code>Functor</code>, there is a type class that captures this pattern. Note that <code>Monad</code> is a class for <em>type constructors</em>, just like <code>Functor</code>.</p>
-<div class="sourceCode" id="cb237"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb237-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Monad</span> m <span class="kw">where</span></a>
-<a class="sourceLine" id="cb237-2" data-line-number="2"><span class="ot">  (&gt;&gt;=) ::</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a></code></pre></div>
+<div class="sourceCode" id="cb237"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb237-1" title="1"><span class="kw">class</span> <span class="dt">Monad</span> m <span class="kw">where</span></a>
+<a class="sourceLine" id="cb237-2" title="2"><span class="ot">  (&gt;&gt;=) ::</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a></code></pre></div>
 <p>There are some additional operations in <code>Monad</code> too:</p>
-<div class="sourceCode" id="cb238"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb238-1" data-line-number="1">  <span class="co">-- lift a normal value into the monad</span></a>
-<a class="sourceLine" id="cb238-2" data-line-number="2"><span class="ot">  return ::</span> a <span class="ot">-&gt;</span> m a</a>
-<a class="sourceLine" id="cb238-3" data-line-number="3">  <span class="co">-- simpler chaining (like our ##&gt;)</span></a>
-<a class="sourceLine" id="cb238-4" data-line-number="4"><span class="ot">  (&gt;&gt;) ::</span> m a <span class="ot">-&gt;</span> m b <span class="ot">-&gt;</span> m b</a>
-<a class="sourceLine" id="cb238-5" data-line-number="5">  a <span class="fu">&gt;&gt;</span> b  <span class="fu">=</span>  a <span class="fu">&gt;&gt;=</span> \_ <span class="ot">-&gt;</span> b     <span class="co">-- remember: _ means ignored argument</span></a></code></pre></div>
+<div class="sourceCode" id="cb238"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb238-1" title="1">  <span class="co">-- lift a normal value into the monad</span></a>
+<a class="sourceLine" id="cb238-2" title="2"><span class="ot">  return ::</span> a <span class="ot">-&gt;</span> m a</a>
+<a class="sourceLine" id="cb238-3" title="3">  <span class="co">-- simpler chaining (like our ##&gt;)</span></a>
+<a class="sourceLine" id="cb238-4" title="4"><span class="ot">  (&gt;&gt;) ::</span> m a <span class="ot">-&gt;</span> m b <span class="ot">-&gt;</span> m b</a>
+<a class="sourceLine" id="cb238-5" title="5">  a <span class="fu">&gt;&gt;</span> b  <span class="fu">=</span>  a <span class="fu">&gt;&gt;=</span> \_ <span class="ot">-&gt;</span> b     <span class="co">-- remember: _ means ignored argument</span></a></code></pre></div>
 <p>Recall that the <code>Functor</code> class was about a generic <code>map</code> operation. Similarly, the <code>Monad</code> class is just about a generic chaining operation.</p>
-<div class="sourceCode" id="cb239"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb239-1" data-line-number="1">fmap<span class="ot"> ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb239-2" data-line-number="2"><span class="ot">(&gt;&gt;=) ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a></code></pre></div>
+<div class="sourceCode" id="cb239"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb239-1" title="1"><span class="fu">fmap</span><span class="ot"> ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb239-2" title="2"><span class="ot">(&gt;&gt;=) ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a></code></pre></div>
 <p>The expression <code>operation &gt;&gt;= next</code> takes a monadic operation <code>operation :: m a</code>, and does some further computation with the value that it produces using <code>next :: a -&gt; m b</code>. If this feels too abstract, just recall how chaining works for <code>Maybe</code>:</p>
-<div class="sourceCode" id="cb240"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb240-1" data-line-number="1"><span class="ot">(&gt;&gt;=) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb240-2" data-line-number="2"><span class="co">-- if we failed, don&#39;t even bother running the next step</span></a>
-<a class="sourceLine" id="cb240-3" data-line-number="3"><span class="dt">Nothing</span> <span class="fu">&gt;&gt;=</span> _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb240-4" data-line-number="4"><span class="co">-- otherwise run the next step</span></a>
-<a class="sourceLine" id="cb240-5" data-line-number="5"><span class="dt">Just</span> x  <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> f x</a></code></pre></div>
+<div class="sourceCode" id="cb240"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb240-1" title="1"><span class="ot">(&gt;&gt;=) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb240-2" title="2"><span class="co">-- if we failed, don&#39;t even bother running the next step</span></a>
+<a class="sourceLine" id="cb240-3" title="3"><span class="dt">Nothing</span> <span class="fu">&gt;&gt;=</span> _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb240-4" title="4"><span class="co">-- otherwise run the next step</span></a>
+<a class="sourceLine" id="cb240-5" title="5"><span class="dt">Just</span> x  <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> f x</a></code></pre></div>
 <h2 id="maybe-is-a-monad"><span class="header-section-number">13.5</span> Maybe is a Monad!</h2>
 <p>Here’s the full <code>Monad</code> instance for <code>Maybe</code> and some examples.</p>
-<div class="sourceCode" id="cb241"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb241-1" data-line-number="1"><span class="kw">instance</span>  <span class="dt">Monad</span> <span class="dt">Maybe</span>  <span class="kw">where</span></a>
-<a class="sourceLine" id="cb241-2" data-line-number="2">    (<span class="dt">Just</span> x) <span class="fu">&gt;&gt;=</span> k      <span class="fu">=</span> k x</a>
-<a class="sourceLine" id="cb241-3" data-line-number="3">    <span class="dt">Nothing</span>  <span class="fu">&gt;&gt;=</span> _      <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb241-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb241-5" data-line-number="5">    (<span class="dt">Just</span> _) <span class="fu">&gt;&gt;</span>  k      <span class="fu">=</span> k</a>
-<a class="sourceLine" id="cb241-6" data-line-number="6">    <span class="dt">Nothing</span>  <span class="fu">&gt;&gt;</span>  _      <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb241-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb241-8" data-line-number="8">    return x            <span class="fu">=</span> <span class="dt">Just</span> x</a></code></pre></div>
-<div class="sourceCode" id="cb242"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb242-1" data-line-number="1"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> return (x<span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb242-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb242-3" data-line-number="3"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span> return (length x)) <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span> return (x<span class="fu">+</span><span class="dv">1</span>))</a>
-<a class="sourceLine" id="cb242-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">6</span></a>
-<a class="sourceLine" id="cb242-5" data-line-number="5"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb242-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb242-7" data-line-number="7"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb242-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb242-9" data-line-number="9"><span class="dt">Just</span> <span class="dv">2</span> <span class="fu">&gt;&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb242-10" data-line-number="10">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb241"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb241-1" title="1"><span class="kw">instance</span>  <span class="dt">Monad</span> <span class="dt">Maybe</span>  <span class="kw">where</span></a>
+<a class="sourceLine" id="cb241-2" title="2">    (<span class="dt">Just</span> x) <span class="fu">&gt;&gt;=</span> k      <span class="fu">=</span> k x</a>
+<a class="sourceLine" id="cb241-3" title="3">    <span class="dt">Nothing</span>  <span class="fu">&gt;&gt;=</span> _      <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb241-4" title="4"></a>
+<a class="sourceLine" id="cb241-5" title="5">    (<span class="dt">Just</span> _) <span class="fu">&gt;&gt;</span>  k      <span class="fu">=</span> k</a>
+<a class="sourceLine" id="cb241-6" title="6">    <span class="dt">Nothing</span>  <span class="fu">&gt;&gt;</span>  _      <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb241-7" title="7"></a>
+<a class="sourceLine" id="cb241-8" title="8">    <span class="fu">return</span> x            <span class="fu">=</span> <span class="dt">Just</span> x</a></code></pre></div>
+<div class="sourceCode" id="cb242"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb242-1" title="1"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="fu">return</span> (x<span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb242-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb242-3" title="3"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span> <span class="fu">return</span> (<span class="fu">length</span> x)) <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span> <span class="fu">return</span> (x<span class="fu">+</span><span class="dv">1</span>))</a>
+<a class="sourceLine" id="cb242-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">6</span></a>
+<a class="sourceLine" id="cb242-5" title="5"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb242-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb242-7" title="7"><span class="dt">Just</span> <span class="st">&quot;HELLO&quot;</span> <span class="fu">&gt;&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb242-8" title="8">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb242-9" title="9"><span class="dt">Just</span> <span class="dv">2</span> <span class="fu">&gt;&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb242-10" title="10">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>Here are the <code>stealSecret</code> and <code>increase</code> examples rewritten with monad operations. The changes are <code>?&gt;</code> to <code>&gt;&gt;=</code> and <code>Just</code> to <code>return</code>.</p>
-<div class="sourceCode" id="cb243"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb243-1" data-line-number="1"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb243-2" data-line-number="2">stealSecret password <span class="fu">=</span></a>
-<a class="sourceLine" id="cb243-3" data-line-number="3">    login password <span class="fu">&gt;&gt;=</span></a>
-<a class="sourceLine" id="cb243-4" data-line-number="4">    secret <span class="fu">&gt;&gt;=</span></a>
-<a class="sourceLine" id="cb243-5" data-line-number="5">    decorate</a>
-<a class="sourceLine" id="cb243-6" data-line-number="6">  <span class="kw">where</span> decorate s <span class="fu">=</span> return (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
-<div class="sourceCode" id="cb244"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb244-1" data-line-number="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
-<a class="sourceLine" id="cb244-2" data-line-number="2"><span class="co">-- but only if val is larger than the current value!</span></a>
-<a class="sourceLine" id="cb244-3" data-line-number="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb244-4" data-line-number="4">increase key val assocs <span class="fu">=</span></a>
-<a class="sourceLine" id="cb244-5" data-line-number="5">    lookup key assocs <span class="fu">&gt;&gt;=</span></a>
-<a class="sourceLine" id="cb244-6" data-line-number="6">    check <span class="fu">&gt;&gt;=</span></a>
-<a class="sourceLine" id="cb244-7" data-line-number="7">    buildResult</a>
-<a class="sourceLine" id="cb244-8" data-line-number="8">  <span class="kw">where</span> check x</a>
-<a class="sourceLine" id="cb244-9" data-line-number="9">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb244-10" data-line-number="10">           <span class="fu">|</span> otherwise <span class="fu">=</span> return x</a>
-<a class="sourceLine" id="cb244-11" data-line-number="11">        buildResult x <span class="fu">=</span> return ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
+<div class="sourceCode" id="cb243"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb243-1" title="1"><span class="ot">stealSecret ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb243-2" title="2">stealSecret password <span class="fu">=</span></a>
+<a class="sourceLine" id="cb243-3" title="3">    login password <span class="fu">&gt;&gt;=</span></a>
+<a class="sourceLine" id="cb243-4" title="4">    secret <span class="fu">&gt;&gt;=</span></a>
+<a class="sourceLine" id="cb243-5" title="5">    decorate</a>
+<a class="sourceLine" id="cb243-6" title="6">  <span class="kw">where</span> decorate s <span class="fu">=</span> <span class="fu">return</span> (<span class="st">&quot;Stole secret: &quot;</span><span class="fu">++</span>s)</a></code></pre></div>
+<div class="sourceCode" id="cb244"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb244-1" title="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
+<a class="sourceLine" id="cb244-2" title="2"><span class="co">-- but only if val is larger than the current value!</span></a>
+<a class="sourceLine" id="cb244-3" title="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb244-4" title="4">increase key val assocs <span class="fu">=</span></a>
+<a class="sourceLine" id="cb244-5" title="5">    <span class="fu">lookup</span> key assocs <span class="fu">&gt;&gt;=</span></a>
+<a class="sourceLine" id="cb244-6" title="6">    check <span class="fu">&gt;&gt;=</span></a>
+<a class="sourceLine" id="cb244-7" title="7">    buildResult</a>
+<a class="sourceLine" id="cb244-8" title="8">  <span class="kw">where</span> check x</a>
+<a class="sourceLine" id="cb244-9" title="9">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb244-10" title="10">           <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="fu">return</span> x</a>
+<a class="sourceLine" id="cb244-11" title="11">        buildResult x <span class="fu">=</span> <span class="fu">return</span> ((key,val) <span class="fu">:</span> delete (key,x) assocs)</a></code></pre></div>
 <h2 id="the-return-of-do"><span class="header-section-number">13.6</span> The Return of <code>do</code></h2>
 <p>Here’s an example of what a complex monad operation might look like.</p>
-<div class="sourceCode" id="cb245"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb245-1" data-line-number="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> continue</a>
-<a class="sourceLine" id="cb245-2" data-line-number="2">  <span class="kw">where</span> continue  x   <span class="fu">=</span> op2 <span class="fu">&gt;&gt;</span> op3 <span class="fu">&gt;&gt;=</span> continue2 x</a>
-<a class="sourceLine" id="cb245-3" data-line-number="3">        continue2 x y <span class="fu">=</span> op4 <span class="fu">&gt;&gt;</span> op5 x y</a></code></pre></div>
+<div class="sourceCode" id="cb245"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb245-1" title="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> continue</a>
+<a class="sourceLine" id="cb245-2" title="2">  <span class="kw">where</span> continue  x   <span class="fu">=</span> op2 <span class="fu">&gt;&gt;</span> op3 <span class="fu">&gt;&gt;=</span> continue2 x</a>
+<a class="sourceLine" id="cb245-3" title="3">        continue2 x y <span class="fu">=</span> op4 <span class="fu">&gt;&gt;</span> op5 x y</a></code></pre></div>
 <p>Let’s see what happens when we transform this code a bit. First off, let’s inline the definitions.</p>
-<div class="sourceCode" id="cb246"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb246-1" data-line-number="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span></a>
-<a class="sourceLine" id="cb246-2" data-line-number="2">               op2 <span class="fu">&gt;&gt;</span></a>
-<a class="sourceLine" id="cb246-3" data-line-number="3">               op3 <span class="fu">&gt;&gt;=</span> (\y <span class="ot">-&gt;</span></a>
-<a class="sourceLine" id="cb246-4" data-line-number="4">                          op4 <span class="fu">&gt;&gt;</span></a>
-<a class="sourceLine" id="cb246-5" data-line-number="5">                          op5 x y))</a></code></pre></div>
+<div class="sourceCode" id="cb246"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb246-1" title="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> (\x <span class="ot">-&gt;</span></a>
+<a class="sourceLine" id="cb246-2" title="2">               op2 <span class="fu">&gt;&gt;</span></a>
+<a class="sourceLine" id="cb246-3" title="3">               op3 <span class="fu">&gt;&gt;=</span> (\y <span class="ot">-&gt;</span></a>
+<a class="sourceLine" id="cb246-4" title="4">                          op4 <span class="fu">&gt;&gt;</span></a>
+<a class="sourceLine" id="cb246-5" title="5">                          op5 x y))</a></code></pre></div>
 <p>Due to lambda expressions continuing to the end of the expression, we can omit the parentheses. Let’s also indent differently.</p>
-<div class="sourceCode" id="cb247"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb247-1" data-line-number="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span></a>
-<a class="sourceLine" id="cb247-2" data-line-number="2">    op2 <span class="fu">&gt;&gt;</span></a>
-<a class="sourceLine" id="cb247-3" data-line-number="3">    op3 <span class="fu">&gt;&gt;=</span> \y <span class="ot">-&gt;</span></a>
-<a class="sourceLine" id="cb247-4" data-line-number="4">    op4 <span class="fu">&gt;&gt;</span></a>
-<a class="sourceLine" id="cb247-5" data-line-number="5">    op5 x y</a></code></pre></div>
+<div class="sourceCode" id="cb247"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb247-1" title="1">f <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span></a>
+<a class="sourceLine" id="cb247-2" title="2">    op2 <span class="fu">&gt;&gt;</span></a>
+<a class="sourceLine" id="cb247-3" title="3">    op3 <span class="fu">&gt;&gt;=</span> \y <span class="ot">-&gt;</span></a>
+<a class="sourceLine" id="cb247-4" title="4">    op4 <span class="fu">&gt;&gt;</span></a>
+<a class="sourceLine" id="cb247-5" title="5">    op5 x y</a></code></pre></div>
 <p>Now we can notice the similarity with <code>do</code> notation. The <code>do</code> block below is actually the same code!</p>
-<div class="sourceCode" id="cb248"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb248-1" data-line-number="1">f <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op1</a>
-<a class="sourceLine" id="cb248-2" data-line-number="2">       op2</a>
-<a class="sourceLine" id="cb248-3" data-line-number="3">       y <span class="ot">&lt;-</span> op3</a>
-<a class="sourceLine" id="cb248-4" data-line-number="4">       op4</a>
-<a class="sourceLine" id="cb248-5" data-line-number="5">       op5 x y</a></code></pre></div>
+<div class="sourceCode" id="cb248"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb248-1" title="1">f <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op1</a>
+<a class="sourceLine" id="cb248-2" title="2">       op2</a>
+<a class="sourceLine" id="cb248-3" title="3">       y <span class="ot">&lt;-</span> op3</a>
+<a class="sourceLine" id="cb248-4" title="4">       op4</a>
+<a class="sourceLine" id="cb248-5" title="5">       op5 x y</a></code></pre></div>
 <p>To clarify, <code>do</code> notation is just a nicer syntax for the monad operations (<code>&gt;&gt;=</code> and <code>&gt;&gt;</code>) and lambdas. Here’s how do notation gets transformed into monad operations. Note! the definition is recursive.</p>
-<div class="sourceCode" id="cb249"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb249-1" data-line-number="1"><span class="kw">do</span> x <span class="ot">&lt;-</span> op a       <span class="fu">~~~&gt;</span>       op a <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="kw">do</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb249-2" data-line-number="2">   <span class="fu">...</span></a></code></pre></div>
-<div class="sourceCode" id="cb250"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb250-1" data-line-number="1"><span class="kw">do</span> op a            <span class="fu">~~~&gt;</span>       op a <span class="fu">&gt;&gt;</span> <span class="kw">do</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb250-2" data-line-number="2">   <span class="fu">...</span></a></code></pre></div>
-<div class="sourceCode" id="cb251"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb251-1" data-line-number="1"><span class="kw">do</span> <span class="kw">let</span> x <span class="fu">=</span> expr    <span class="fu">~~~&gt;</span>       <span class="kw">let</span> x <span class="fu">=</span> expr <span class="kw">in</span> <span class="kw">do</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb251-2" data-line-number="2">   <span class="fu">...</span></a></code></pre></div>
-<div class="sourceCode" id="cb252"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb252-1" data-line-number="1"><span class="kw">do</span> finalOp         <span class="fu">~~~&gt;</span>       finalOp</a></code></pre></div>
+<div class="sourceCode" id="cb249"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb249-1" title="1"><span class="kw">do</span> x <span class="ot">&lt;-</span> op a       <span class="fu">~~~&gt;</span>       op a <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="kw">do</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb249-2" title="2">   <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb250"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb250-1" title="1"><span class="kw">do</span> op a            <span class="fu">~~~&gt;</span>       op a <span class="fu">&gt;&gt;</span> <span class="kw">do</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb250-2" title="2">   <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb251"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb251-1" title="1"><span class="kw">do</span> <span class="kw">let</span> x <span class="fu">=</span> expr    <span class="fu">~~~&gt;</span>       <span class="kw">let</span> x <span class="fu">=</span> expr <span class="kw">in</span> <span class="kw">do</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb251-2" title="2">   <span class="fu">...</span></a></code></pre></div>
+<div class="sourceCode" id="cb252"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb252-1" title="1"><span class="kw">do</span> finalOp         <span class="fu">~~~&gt;</span>       finalOp</a></code></pre></div>
 <p>Here’s <code>safeNth</code> using do notation:</p>
-<div class="sourceCode" id="cb253"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb253-1" data-line-number="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb253-2" data-line-number="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb253-3" data-line-number="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb253-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb253-5" data-line-number="5"><span class="ot">safeTail ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
-<a class="sourceLine" id="cb253-6" data-line-number="6">safeTail [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb253-7" data-line-number="7">safeTail (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> xs</a>
-<a class="sourceLine" id="cb253-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb253-9" data-line-number="9"><span class="ot">safeNth ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb253-10" data-line-number="10">safeNth <span class="dv">0</span> xs <span class="fu">=</span> safeHead xs</a>
-<a class="sourceLine" id="cb253-11" data-line-number="11">safeNth n xs <span class="fu">=</span> <span class="kw">do</span> t <span class="ot">&lt;-</span> safeTail xs</a>
-<a class="sourceLine" id="cb253-12" data-line-number="12">                  safeNth (n<span class="fu">-</span><span class="dv">1</span>) t</a></code></pre></div>
+<div class="sourceCode" id="cb253"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb253-1" title="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb253-2" title="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb253-3" title="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb253-4" title="4"></a>
+<a class="sourceLine" id="cb253-5" title="5"><span class="ot">safeTail ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
+<a class="sourceLine" id="cb253-6" title="6">safeTail [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb253-7" title="7">safeTail (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> xs</a>
+<a class="sourceLine" id="cb253-8" title="8"></a>
+<a class="sourceLine" id="cb253-9" title="9"><span class="ot">safeNth ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb253-10" title="10">safeNth <span class="dv">0</span> xs <span class="fu">=</span> safeHead xs</a>
+<a class="sourceLine" id="cb253-11" title="11">safeNth n xs <span class="fu">=</span> <span class="kw">do</span> t <span class="ot">&lt;-</span> safeTail xs</a>
+<a class="sourceLine" id="cb253-12" title="12">                  safeNth (n<span class="fu">-</span><span class="dv">1</span>) t</a></code></pre></div>
 <p>Here is <code>increase</code> one last time, now with do notation</p>
-<div class="sourceCode" id="cb254"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb254-1" data-line-number="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
-<a class="sourceLine" id="cb254-2" data-line-number="2"><span class="co">-- but only if val is larger than the current value!</span></a>
-<a class="sourceLine" id="cb254-3" data-line-number="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb254-4" data-line-number="4">increase key val assocs <span class="fu">=</span></a>
-<a class="sourceLine" id="cb254-5" data-line-number="5">  <span class="kw">do</span> oldVal <span class="ot">&lt;-</span> lookup key assocs</a>
-<a class="sourceLine" id="cb254-6" data-line-number="6">     check oldVal</a>
-<a class="sourceLine" id="cb254-7" data-line-number="7">     return ((key,val) <span class="fu">:</span> delete (key,oldVal) assocs)</a>
-<a class="sourceLine" id="cb254-8" data-line-number="8">  <span class="kw">where</span> check x</a>
-<a class="sourceLine" id="cb254-9" data-line-number="9">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb254-10" data-line-number="10">           <span class="fu">|</span> otherwise <span class="fu">=</span> return x</a></code></pre></div>
+<div class="sourceCode" id="cb254"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb254-1" title="1"><span class="co">-- Set the value of key to val in the given key-value list,</span></a>
+<a class="sourceLine" id="cb254-2" title="2"><span class="co">-- but only if val is larger than the current value!</span></a>
+<a class="sourceLine" id="cb254-3" title="3"><span class="ot">increase ::</span> <span class="dt">Eq</span> a <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(a,<span class="dt">Int</span>)] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [(a,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb254-4" title="4">increase key val assocs <span class="fu">=</span></a>
+<a class="sourceLine" id="cb254-5" title="5">  <span class="kw">do</span> oldVal <span class="ot">&lt;-</span> <span class="fu">lookup</span> key assocs</a>
+<a class="sourceLine" id="cb254-6" title="6">     check oldVal</a>
+<a class="sourceLine" id="cb254-7" title="7">     <span class="fu">return</span> ((key,val) <span class="fu">:</span> delete (key,oldVal) assocs)</a>
+<a class="sourceLine" id="cb254-8" title="8">  <span class="kw">where</span> check x</a>
+<a class="sourceLine" id="cb254-9" title="9">           <span class="fu">|</span> val <span class="fu">&lt;</span> x   <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb254-10" title="10">           <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="fu">return</span> x</a></code></pre></div>
 <h2 id="logger-is-a-monad"><span class="header-section-number">13.7</span> Logger is a Monad!</h2>
 <p>We should be able to write a <code>Monad</code> instance for <code>Logger</code> ourselves, by setting <code>&gt;&gt;=</code> to <code>#&gt;</code>. However, due to <a href="https://wiki.haskell.org/Functor-Applicative-Monad_Proposal">recent changes in the Haskell language</a> we must implement <code>Functor</code> and <code>Applicative</code> instances to be allowed to implement the <code>Monad</code> instance. <code>Functor</code> we’ve already met, but what’s <code>Applicative</code>? We’ll find out later. Let’s implement the instances:</p>
 <!-- TODO should this be in an Examples file as well? -->
-<div class="sourceCode" id="cb255"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb255-1" data-line-number="1"><span class="kw">import</span> <span class="dt">Control.Monad</span></a>
-<a class="sourceLine" id="cb255-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb255-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Logger</span> a <span class="fu">=</span> <span class="dt">Logger</span> [<span class="dt">String</span>] a  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb255-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb255-5" data-line-number="5"><span class="ot">msg ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
-<a class="sourceLine" id="cb255-6" data-line-number="6">msg s <span class="fu">=</span> <span class="dt">Logger</span> [s] ()</a>
-<a class="sourceLine" id="cb255-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb255-8" data-line-number="8"><span class="co">-- The Functor instance just maps over the stored value</span></a>
-<a class="sourceLine" id="cb255-9" data-line-number="9"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb255-10" data-line-number="10">  fmap f (<span class="dt">Logger</span> log x) <span class="fu">=</span> <span class="dt">Logger</span> log (f x)</a>
-<a class="sourceLine" id="cb255-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb255-12" data-line-number="12"><span class="co">-- This is an Applicative instance that works for any</span></a>
-<a class="sourceLine" id="cb255-13" data-line-number="13"><span class="co">-- monad, you can just ignore it for now. We&#39;ll get back</span></a>
-<a class="sourceLine" id="cb255-14" data-line-number="14"><span class="co">-- to Applicative later.</span></a>
-<a class="sourceLine" id="cb255-15" data-line-number="15"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb255-16" data-line-number="16">  pure <span class="fu">=</span> return</a>
-<a class="sourceLine" id="cb255-17" data-line-number="17">  (<span class="fu">&lt;*&gt;</span>) <span class="fu">=</span> ap</a>
-<a class="sourceLine" id="cb255-18" data-line-number="18"></a>
-<a class="sourceLine" id="cb255-19" data-line-number="19"><span class="co">-- Finally, the Monad instance</span></a>
-<a class="sourceLine" id="cb255-20" data-line-number="20"><span class="kw">instance</span> <span class="dt">Monad</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb255-21" data-line-number="21">  return x <span class="fu">=</span> <span class="dt">Logger</span> [] x</a>
-<a class="sourceLine" id="cb255-22" data-line-number="22">  <span class="dt">Logger</span> la a <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b</a>
-<a class="sourceLine" id="cb255-23" data-line-number="23">    <span class="kw">where</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> f a</a></code></pre></div>
+<div class="sourceCode" id="cb255"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb255-1" title="1"><span class="kw">import</span> <span class="dt">Control.Monad</span></a>
+<a class="sourceLine" id="cb255-2" title="2"></a>
+<a class="sourceLine" id="cb255-3" title="3"><span class="kw">data</span> <span class="dt">Logger</span> a <span class="fu">=</span> <span class="dt">Logger</span> [<span class="dt">String</span>] a  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb255-4" title="4"></a>
+<a class="sourceLine" id="cb255-5" title="5"><span class="ot">msg ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
+<a class="sourceLine" id="cb255-6" title="6">msg s <span class="fu">=</span> <span class="dt">Logger</span> [s] ()</a>
+<a class="sourceLine" id="cb255-7" title="7"></a>
+<a class="sourceLine" id="cb255-8" title="8"><span class="co">-- The Functor instance just maps over the stored value</span></a>
+<a class="sourceLine" id="cb255-9" title="9"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb255-10" title="10">  <span class="fu">fmap</span> f (<span class="dt">Logger</span> <span class="fu">log</span> x) <span class="fu">=</span> <span class="dt">Logger</span> <span class="fu">log</span> (f x)</a>
+<a class="sourceLine" id="cb255-11" title="11"></a>
+<a class="sourceLine" id="cb255-12" title="12"><span class="co">-- This is an Applicative instance that works for any</span></a>
+<a class="sourceLine" id="cb255-13" title="13"><span class="co">-- monad, you can just ignore it for now. We&#39;ll get back</span></a>
+<a class="sourceLine" id="cb255-14" title="14"><span class="co">-- to Applicative later.</span></a>
+<a class="sourceLine" id="cb255-15" title="15"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb255-16" title="16">  <span class="fu">pure</span> <span class="fu">=</span> <span class="fu">return</span></a>
+<a class="sourceLine" id="cb255-17" title="17">  (<span class="fu">&lt;*&gt;</span>) <span class="fu">=</span> ap</a>
+<a class="sourceLine" id="cb255-18" title="18"></a>
+<a class="sourceLine" id="cb255-19" title="19"><span class="co">-- Finally, the Monad instance</span></a>
+<a class="sourceLine" id="cb255-20" title="20"><span class="kw">instance</span> <span class="dt">Monad</span> <span class="dt">Logger</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb255-21" title="21">  <span class="fu">return</span> x <span class="fu">=</span> <span class="dt">Logger</span> [] x</a>
+<a class="sourceLine" id="cb255-22" title="22">  <span class="dt">Logger</span> la a <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> <span class="dt">Logger</span> (la<span class="fu">++</span>lb) b</a>
+<a class="sourceLine" id="cb255-23" title="23">    <span class="kw">where</span> <span class="dt">Logger</span> lb b <span class="fu">=</span> f a</a></code></pre></div>
 <p>We don’t need the <code>nomsg</code> operation any more since it’s just <code>return</code>. We can also reimplement the <code>annotate</code> operation using monad operations.</p>
-<div class="sourceCode" id="cb256"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb256-1" data-line-number="1"><span class="ot">nomsg ::</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
-<a class="sourceLine" id="cb256-2" data-line-number="2">nomsg x <span class="fu">=</span> return x</a>
-<a class="sourceLine" id="cb256-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb256-4" data-line-number="4"><span class="ot">annotate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
-<a class="sourceLine" id="cb256-5" data-line-number="5">annotate s x <span class="fu">=</span> msg s <span class="fu">&gt;&gt;</span> return x</a></code></pre></div>
+<div class="sourceCode" id="cb256"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb256-1" title="1"><span class="ot">nomsg ::</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
+<a class="sourceLine" id="cb256-2" title="2">nomsg x <span class="fu">=</span> <span class="fu">return</span> x</a>
+<a class="sourceLine" id="cb256-3" title="3"></a>
+<a class="sourceLine" id="cb256-4" title="4"><span class="ot">annotate ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Logger</span> a</a>
+<a class="sourceLine" id="cb256-5" title="5">annotate s x <span class="fu">=</span> msg s <span class="fu">&gt;&gt;</span> <span class="fu">return</span> x</a></code></pre></div>
 <p>Here are the <code>compute</code> and <code>filterLog</code> examples rewritten using do-notation. Note how nice <code>filterLog</code> is with do-notation.</p>
-<div class="sourceCode" id="cb257"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb257-1" data-line-number="1">compute x <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb257-2" data-line-number="2">  a <span class="ot">&lt;-</span> annotate <span class="st">&quot;^2&quot;</span> (x<span class="fu">*</span>x)</a>
-<a class="sourceLine" id="cb257-3" data-line-number="3">  b <span class="ot">&lt;-</span> annotate <span class="st">&quot;+1&quot;</span> (a<span class="fu">+</span><span class="dv">1</span>)</a>
-<a class="sourceLine" id="cb257-4" data-line-number="4">  annotate <span class="st">&quot;*2&quot;</span> (b<span class="fu">*</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb257-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb257-6" data-line-number="6"><span class="ot">filterLog ::</span> (<span class="dt">Show</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> [a]</a>
-<a class="sourceLine" id="cb257-7" data-line-number="7">filterLog f [] <span class="fu">=</span> return []</a>
-<a class="sourceLine" id="cb257-8" data-line-number="8">filterLog f (x<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb257-9" data-line-number="9">   <span class="fu">|</span> f x       <span class="fu">=</span> <span class="kw">do</span> msg (<span class="st">&quot;keeping &quot;</span><span class="fu">++</span>show x)</a>
-<a class="sourceLine" id="cb257-10" data-line-number="10">                    xs&#39; <span class="ot">&lt;-</span> filterLog f xs</a>
-<a class="sourceLine" id="cb257-11" data-line-number="11">                    return (x<span class="fu">:</span>xs&#39;)</a>
-<a class="sourceLine" id="cb257-12" data-line-number="12">   <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="kw">do</span> msg (<span class="st">&quot;dropping &quot;</span><span class="fu">++</span>show x)</a>
-<a class="sourceLine" id="cb257-13" data-line-number="13">                    filterLog f xs</a></code></pre></div>
-<div class="sourceCode" id="cb258"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb258-1" data-line-number="1">compute <span class="dv">3</span></a>
-<a class="sourceLine" id="cb258-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;^2&quot;</span>,<span class="st">&quot;+1&quot;</span>,<span class="st">&quot;*2&quot;</span>] <span class="dv">20</span></a>
-<a class="sourceLine" id="cb258-3" data-line-number="3">filterLog (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb258-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;keeping 1&quot;</span>,<span class="st">&quot;dropping -2&quot;</span>,<span class="st">&quot;keeping 3&quot;</span>,<span class="st">&quot;dropping -4&quot;</span>,<span class="st">&quot;dropping 0&quot;</span>] [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb257"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb257-1" title="1">compute x <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb257-2" title="2">  a <span class="ot">&lt;-</span> annotate <span class="st">&quot;^2&quot;</span> (x<span class="fu">*</span>x)</a>
+<a class="sourceLine" id="cb257-3" title="3">  b <span class="ot">&lt;-</span> annotate <span class="st">&quot;+1&quot;</span> (a<span class="fu">+</span><span class="dv">1</span>)</a>
+<a class="sourceLine" id="cb257-4" title="4">  annotate <span class="st">&quot;*2&quot;</span> (b<span class="fu">*</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb257-5" title="5"></a>
+<a class="sourceLine" id="cb257-6" title="6"><span class="ot">filterLog ::</span> (<span class="dt">Show</span> a) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> [a]</a>
+<a class="sourceLine" id="cb257-7" title="7">filterLog f [] <span class="fu">=</span> <span class="fu">return</span> []</a>
+<a class="sourceLine" id="cb257-8" title="8">filterLog f (x<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb257-9" title="9">   <span class="fu">|</span> f x       <span class="fu">=</span> <span class="kw">do</span> msg (<span class="st">&quot;keeping &quot;</span><span class="fu">++show</span> x)</a>
+<a class="sourceLine" id="cb257-10" title="10">                    xs&#39; <span class="ot">&lt;-</span> filterLog f xs</a>
+<a class="sourceLine" id="cb257-11" title="11">                    <span class="fu">return</span> (x<span class="fu">:</span>xs&#39;)</a>
+<a class="sourceLine" id="cb257-12" title="12">   <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="kw">do</span> msg (<span class="st">&quot;dropping &quot;</span><span class="fu">++show</span> x)</a>
+<a class="sourceLine" id="cb257-13" title="13">                    filterLog f xs</a></code></pre></div>
+<div class="sourceCode" id="cb258"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb258-1" title="1">compute <span class="dv">3</span></a>
+<a class="sourceLine" id="cb258-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;^2&quot;</span>,<span class="st">&quot;+1&quot;</span>,<span class="st">&quot;*2&quot;</span>] <span class="dv">20</span></a>
+<a class="sourceLine" id="cb258-3" title="3">filterLog (<span class="fu">&gt;</span><span class="dv">0</span>) [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb258-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;keeping 1&quot;</span>,<span class="st">&quot;dropping -2&quot;</span>,<span class="st">&quot;keeping 3&quot;</span>,<span class="st">&quot;dropping -4&quot;</span>,<span class="st">&quot;dropping 0&quot;</span>] [<span class="dv">1</span>,<span class="dv">3</span>]</a></code></pre></div>
 <h2 id="the-state-monad"><span class="header-section-number">13.8</span> The State Monad</h2>
 <p>Haskell’s <code>State</code> monad is a generalized version of our <code>BankOp</code> type. The <code>State</code> type is parameterized by two types, the first being the type of the state, and the second the type of the value produced. <code>State Bank a</code> would be equivalent to our <code>BankOp a</code>. You can find the <code>State</code> monad in the <a href="https://downloads.haskell.org/~ghc/latest/docs/html/libraries/transformers-0.5.6.2/Control-Monad-Trans-State.html">module <code>Control.Monad.Trans.State</code> of the <code>transformers</code> package</a>. Here’s a simplified implementation of <code>State</code>.</p>
-<div class="sourceCode" id="cb259"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb259-1" data-line-number="1"><span class="kw">data</span> <span class="dt">State</span> s a <span class="fu">=</span> <span class="dt">State</span> (s <span class="ot">-&gt;</span> (a,s))</a>
-<a class="sourceLine" id="cb259-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb259-3" data-line-number="3">runState (<span class="dt">State</span> f) s <span class="fu">=</span> f s</a>
-<a class="sourceLine" id="cb259-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb259-5" data-line-number="5"><span class="co">-- operation that overwrites the state (and produces ())</span></a>
-<a class="sourceLine" id="cb259-6" data-line-number="6"><span class="ot">put ::</span> s <span class="ot">-&gt;</span> <span class="dt">State</span> s ()</a>
-<a class="sourceLine" id="cb259-7" data-line-number="7">put state <span class="fu">=</span> <span class="dt">State</span> (\oldState <span class="ot">-&gt;</span> ((),state))</a>
-<a class="sourceLine" id="cb259-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb259-9" data-line-number="9"><span class="co">-- operation that produces the current state</span></a>
-<a class="sourceLine" id="cb259-10" data-line-number="10"><span class="ot">get ::</span> <span class="dt">State</span> s s</a>
-<a class="sourceLine" id="cb259-11" data-line-number="11">get <span class="fu">=</span> <span class="dt">State</span> (\state <span class="ot">-&gt;</span> (state,state))</a>
-<a class="sourceLine" id="cb259-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb259-13" data-line-number="13"><span class="co">-- operation that modifies the current state with a function (and produces ())</span></a>
-<a class="sourceLine" id="cb259-14" data-line-number="14"><span class="ot">modify ::</span> (s <span class="ot">-&gt;</span> s) <span class="ot">-&gt;</span> <span class="dt">State</span> s ()</a>
-<a class="sourceLine" id="cb259-15" data-line-number="15">modify f <span class="fu">=</span> <span class="dt">State</span> (\state <span class="ot">-&gt;</span> ((), f state))</a>
-<a class="sourceLine" id="cb259-16" data-line-number="16"></a>
-<a class="sourceLine" id="cb259-17" data-line-number="17"><span class="co">-- Functor and Applicative instances skipped</span></a>
-<a class="sourceLine" id="cb259-18" data-line-number="18"></a>
-<a class="sourceLine" id="cb259-19" data-line-number="19"><span class="kw">instance</span> <span class="dt">Monad</span> (<span class="dt">State</span> s) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb259-20" data-line-number="20">  return x <span class="fu">=</span> <span class="dt">State</span> (\s <span class="ot">-&gt;</span> (x,s))</a>
-<a class="sourceLine" id="cb259-21" data-line-number="21"></a>
-<a class="sourceLine" id="cb259-22" data-line-number="22">  op <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> <span class="dt">State</span> h</a>
-<a class="sourceLine" id="cb259-23" data-line-number="23">    <span class="kw">where</span> h state0 <span class="fu">=</span> <span class="kw">let</span> (val,state1) <span class="fu">=</span> runState op state0</a>
-<a class="sourceLine" id="cb259-24" data-line-number="24">                         op2 <span class="fu">=</span> f val</a>
-<a class="sourceLine" id="cb259-25" data-line-number="25">                     <span class="kw">in</span> runState op2 state1</a></code></pre></div>
+<div class="sourceCode" id="cb259"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb259-1" title="1"><span class="kw">data</span> <span class="dt">State</span> s a <span class="fu">=</span> <span class="dt">State</span> (s <span class="ot">-&gt;</span> (a,s))</a>
+<a class="sourceLine" id="cb259-2" title="2"></a>
+<a class="sourceLine" id="cb259-3" title="3">runState (<span class="dt">State</span> f) s <span class="fu">=</span> f s</a>
+<a class="sourceLine" id="cb259-4" title="4"></a>
+<a class="sourceLine" id="cb259-5" title="5"><span class="co">-- operation that overwrites the state (and produces ())</span></a>
+<a class="sourceLine" id="cb259-6" title="6"><span class="ot">put ::</span> s <span class="ot">-&gt;</span> <span class="dt">State</span> s ()</a>
+<a class="sourceLine" id="cb259-7" title="7">put state <span class="fu">=</span> <span class="dt">State</span> (\oldState <span class="ot">-&gt;</span> ((),state))</a>
+<a class="sourceLine" id="cb259-8" title="8"></a>
+<a class="sourceLine" id="cb259-9" title="9"><span class="co">-- operation that produces the current state</span></a>
+<a class="sourceLine" id="cb259-10" title="10"><span class="ot">get ::</span> <span class="dt">State</span> s s</a>
+<a class="sourceLine" id="cb259-11" title="11">get <span class="fu">=</span> <span class="dt">State</span> (\state <span class="ot">-&gt;</span> (state,state))</a>
+<a class="sourceLine" id="cb259-12" title="12"></a>
+<a class="sourceLine" id="cb259-13" title="13"><span class="co">-- operation that modifies the current state with a function (and produces ())</span></a>
+<a class="sourceLine" id="cb259-14" title="14"><span class="ot">modify ::</span> (s <span class="ot">-&gt;</span> s) <span class="ot">-&gt;</span> <span class="dt">State</span> s ()</a>
+<a class="sourceLine" id="cb259-15" title="15">modify f <span class="fu">=</span> <span class="dt">State</span> (\state <span class="ot">-&gt;</span> ((), f state))</a>
+<a class="sourceLine" id="cb259-16" title="16"></a>
+<a class="sourceLine" id="cb259-17" title="17"><span class="co">-- Functor and Applicative instances skipped</span></a>
+<a class="sourceLine" id="cb259-18" title="18"></a>
+<a class="sourceLine" id="cb259-19" title="19"><span class="kw">instance</span> <span class="dt">Monad</span> (<span class="dt">State</span> s) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb259-20" title="20">  <span class="fu">return</span> x <span class="fu">=</span> <span class="dt">State</span> (\s <span class="ot">-&gt;</span> (x,s))</a>
+<a class="sourceLine" id="cb259-21" title="21"></a>
+<a class="sourceLine" id="cb259-22" title="22">  op <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> <span class="dt">State</span> h</a>
+<a class="sourceLine" id="cb259-23" title="23">    <span class="kw">where</span> h state0 <span class="fu">=</span> <span class="kw">let</span> (val,state1) <span class="fu">=</span> runState op state0</a>
+<a class="sourceLine" id="cb259-24" title="24">                         op2 <span class="fu">=</span> f val</a>
+<a class="sourceLine" id="cb259-25" title="25">                     <span class="kw">in</span> runState op2 state1</a></code></pre></div>
 <p>Note how we declare an instance <code>Monad (State s)</code>. We’re using a <em>partially-applied type constructor</em> because instances of <code>Monad</code> can only be declared for type constructors that take one more type parameter. This might be a bit clearer if you look at how <code>m</code>, <code>Maybe</code> and <code>State</code> occur in the type of <code>&gt;&gt;=</code> below.</p>
-<div class="sourceCode" id="cb260"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb260-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Monad</span> m <span class="kw">where</span></a>
-<a class="sourceLine" id="cb260-2" data-line-number="2"><span class="ot">  (&gt;&gt;=) ::</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a>
-<a class="sourceLine" id="cb260-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb260-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">Monad</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb260-5" data-line-number="5"><span class="ot">  (&gt;&gt;=) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
-<a class="sourceLine" id="cb260-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb260-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">Monad</span> (<span class="dt">State</span> s) <span class="kw">where</span></a>
-<a class="sourceLine" id="cb260-8" data-line-number="8"><span class="ot">  (&gt;&gt;=) ::</span> <span class="dt">State</span> s a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">State</span> s b) <span class="ot">-&gt;</span> <span class="dt">State</span> s b</a></code></pre></div>
+<div class="sourceCode" id="cb260"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb260-1" title="1"><span class="kw">class</span> <span class="dt">Monad</span> m <span class="kw">where</span></a>
+<a class="sourceLine" id="cb260-2" title="2"><span class="ot">  (&gt;&gt;=) ::</span> m a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m b</a>
+<a class="sourceLine" id="cb260-3" title="3"></a>
+<a class="sourceLine" id="cb260-4" title="4"><span class="kw">instance</span> <span class="dt">Monad</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb260-5" title="5"><span class="ot">  (&gt;&gt;=) ::</span> <span class="dt">Maybe</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b) <span class="ot">-&gt;</span> <span class="dt">Maybe</span> b</a>
+<a class="sourceLine" id="cb260-6" title="6"></a>
+<a class="sourceLine" id="cb260-7" title="7"><span class="kw">instance</span> <span class="dt">Monad</span> (<span class="dt">State</span> s) <span class="kw">where</span></a>
+<a class="sourceLine" id="cb260-8" title="8"><span class="ot">  (&gt;&gt;=) ::</span> <span class="dt">State</span> s a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> <span class="dt">State</span> s b) <span class="ot">-&gt;</span> <span class="dt">State</span> s b</a></code></pre></div>
 <p>Let’s look at some examples of working with <code>State</code>. To start off, let’s consider computations of type <code>State Int a</code>, which represent working with a simple counter.</p>
-<div class="sourceCode" id="cb261"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb261-1" data-line-number="1"><span class="co">-- adds i to the value of the counter</span></a>
-<a class="sourceLine" id="cb261-2" data-line-number="2"><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">State</span> <span class="dt">Int</span> ()</a>
-<a class="sourceLine" id="cb261-3" data-line-number="3">add i <span class="fu">=</span> <span class="kw">do</span> old <span class="ot">&lt;-</span> get</a>
-<a class="sourceLine" id="cb261-4" data-line-number="4">           put (old<span class="fu">+</span>i)</a></code></pre></div>
-<div class="sourceCode" id="cb262"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb262-1" data-line-number="1">runState (add <span class="dv">1</span> <span class="fu">&gt;&gt;</span> add <span class="dv">3</span> <span class="fu">&gt;&gt;</span> add <span class="dv">5</span> <span class="fu">&gt;&gt;</span> add <span class="dv">6</span>) <span class="dv">0</span></a>
-<a class="sourceLine" id="cb262-2" data-line-number="2">  <span class="fu">==&gt;</span> ((),<span class="dv">15</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb263"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb263-1" data-line-number="1"><span class="ot">example ::</span> <span class="dt">State</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb263-2" data-line-number="2">example <span class="fu">=</span> <span class="kw">do</span> add <span class="dv">3</span>           <span class="co">-- increment state by 3</span></a>
-<a class="sourceLine" id="cb263-3" data-line-number="3">             value <span class="ot">&lt;-</span> get    <span class="co">-- value is current state, i.e. initial+3</span></a>
-<a class="sourceLine" id="cb263-4" data-line-number="4">             add <span class="dv">1000</span>        <span class="co">-- increment state by 1000</span></a>
-<a class="sourceLine" id="cb263-5" data-line-number="5">             put (value <span class="fu">+</span> <span class="dv">1</span>) <span class="co">-- overwrite state with value+1, i.e. initial+4</span></a>
-<a class="sourceLine" id="cb263-6" data-line-number="6">             return value    <span class="co">-- produce value, i.e. intial+3</span></a></code></pre></div>
-<div class="sourceCode" id="cb264"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb264-1" data-line-number="1">runState example <span class="dv">1</span></a>
-<a class="sourceLine" id="cb264-2" data-line-number="2">  <span class="fu">==&gt;</span> (<span class="dv">4</span>,<span class="dv">5</span>)           <span class="co">-- initial is 1, state is initial+4=5, produces initial+3=4</span></a></code></pre></div>
+<div class="sourceCode" id="cb261"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb261-1" title="1"><span class="co">-- adds i to the value of the counter</span></a>
+<a class="sourceLine" id="cb261-2" title="2"><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">State</span> <span class="dt">Int</span> ()</a>
+<a class="sourceLine" id="cb261-3" title="3">add i <span class="fu">=</span> <span class="kw">do</span> old <span class="ot">&lt;-</span> get</a>
+<a class="sourceLine" id="cb261-4" title="4">           put (old<span class="fu">+</span>i)</a></code></pre></div>
+<div class="sourceCode" id="cb262"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb262-1" title="1">runState (add <span class="dv">1</span> <span class="fu">&gt;&gt;</span> add <span class="dv">3</span> <span class="fu">&gt;&gt;</span> add <span class="dv">5</span> <span class="fu">&gt;&gt;</span> add <span class="dv">6</span>) <span class="dv">0</span></a>
+<a class="sourceLine" id="cb262-2" title="2">  <span class="fu">==&gt;</span> ((),<span class="dv">15</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb263"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb263-1" title="1"><span class="ot">example ::</span> <span class="dt">State</span> <span class="dt">Int</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb263-2" title="2">example <span class="fu">=</span> <span class="kw">do</span> add <span class="dv">3</span>           <span class="co">-- increment state by 3</span></a>
+<a class="sourceLine" id="cb263-3" title="3">             value <span class="ot">&lt;-</span> get    <span class="co">-- value is current state, i.e. initial+3</span></a>
+<a class="sourceLine" id="cb263-4" title="4">             add <span class="dv">1000</span>        <span class="co">-- increment state by 1000</span></a>
+<a class="sourceLine" id="cb263-5" title="5">             put (value <span class="fu">+</span> <span class="dv">1</span>) <span class="co">-- overwrite state with value+1, i.e. initial+4</span></a>
+<a class="sourceLine" id="cb263-6" title="6">             <span class="fu">return</span> value    <span class="co">-- produce value, i.e. intial+3</span></a></code></pre></div>
+<div class="sourceCode" id="cb264"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb264-1" title="1">runState example <span class="dv">1</span></a>
+<a class="sourceLine" id="cb264-2" title="2">  <span class="fu">==&gt;</span> (<span class="dv">4</span>,<span class="dv">5</span>)           <span class="co">-- initial is 1, state is initial+4=5, produces initial+3=4</span></a></code></pre></div>
 <p>Note how a value of type <code>State s a</code> represents a process that transforms the state (just like <code>BankOp</code>). The initial state must be supplied using <code>runState</code>. Again, having to use <code>runState</code> makes the distinction between <em>defining</em> operations and <em>executing them</em> clearer.</p>
 <p>A state can replace an accumulator parameter when processing a list. Here are two examples: finding the largest element of a list, and finding values in a list that occur directly after a <code>0</code>.</p>
-<div class="sourceCode" id="cb265"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb265-1" data-line-number="1"><span class="ot">findLargest ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> a ()</a>
-<a class="sourceLine" id="cb265-2" data-line-number="2">findLargest [] <span class="fu">=</span> return ()</a>
-<a class="sourceLine" id="cb265-3" data-line-number="3">findLargest (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb265-4" data-line-number="4">  modify (\y <span class="ot">-&gt;</span> max x y)  <span class="co">-- update state with max of current value and previous largest value</span></a>
-<a class="sourceLine" id="cb265-5" data-line-number="5">  findLargest xs          <span class="co">-- process rest of list</span></a></code></pre></div>
-<div class="sourceCode" id="cb266"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb266-1" data-line-number="1">runState (findLargest [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">7</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb267"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb267-1" data-line-number="1"><span class="co">-- store the given value in the state list</span></a>
-<a class="sourceLine" id="cb267-2" data-line-number="2"><span class="ot">remember ::</span> a <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
-<a class="sourceLine" id="cb267-3" data-line-number="3">remember x <span class="fu">=</span> modify (x<span class="fu">:</span>)</a>
-<a class="sourceLine" id="cb267-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb267-5" data-line-number="5"><span class="ot">valuesAfterZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb267-6" data-line-number="6">valuesAfterZero xs <span class="fu">=</span> runState (go xs) []</a>
-<a class="sourceLine" id="cb267-7" data-line-number="7">  <span class="kw">where</span><span class="ot"> go ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
-<a class="sourceLine" id="cb267-8" data-line-number="8">        go (<span class="dv">0</span><span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> remember y</a>
-<a class="sourceLine" id="cb267-9" data-line-number="9">                         go (y<span class="fu">:</span>xs)</a>
-<a class="sourceLine" id="cb267-10" data-line-number="10">        go (x<span class="fu">:</span>xs) <span class="fu">=</span> go xs</a>
-<a class="sourceLine" id="cb267-11" data-line-number="11">        go [] <span class="fu">=</span> return ()</a></code></pre></div>
-<div class="sourceCode" id="cb268"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb268-1" data-line-number="1">valuesAfterZero [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">0</span>,<span class="dv">4</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb268-2" data-line-number="2">  <span class="fu">==&gt;</span> ((),[<span class="dv">6</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">4</span>,<span class="dv">1</span>])</a></code></pre></div>
+<div class="sourceCode" id="cb265"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb265-1" title="1"><span class="ot">findLargest ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> a ()</a>
+<a class="sourceLine" id="cb265-2" title="2">findLargest [] <span class="fu">=</span> <span class="fu">return</span> ()</a>
+<a class="sourceLine" id="cb265-3" title="3">findLargest (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb265-4" title="4">  modify (\y <span class="ot">-&gt;</span> <span class="fu">max</span> x y)  <span class="co">-- update state with max of current value and previous largest value</span></a>
+<a class="sourceLine" id="cb265-5" title="5">  findLargest xs          <span class="co">-- process rest of list</span></a></code></pre></div>
+<div class="sourceCode" id="cb266"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb266-1" title="1">runState (findLargest [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">7</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb267"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb267-1" title="1"><span class="co">-- store the given value in the state list</span></a>
+<a class="sourceLine" id="cb267-2" title="2"><span class="ot">remember ::</span> a <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
+<a class="sourceLine" id="cb267-3" title="3">remember x <span class="fu">=</span> modify (x<span class="fu">:</span>)</a>
+<a class="sourceLine" id="cb267-4" title="4"></a>
+<a class="sourceLine" id="cb267-5" title="5"><span class="ot">valuesAfterZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb267-6" title="6">valuesAfterZero xs <span class="fu">=</span> runState (go xs) []</a>
+<a class="sourceLine" id="cb267-7" title="7">  <span class="kw">where</span><span class="ot"> go ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
+<a class="sourceLine" id="cb267-8" title="8">        go (<span class="dv">0</span><span class="fu">:</span>y<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> remember y</a>
+<a class="sourceLine" id="cb267-9" title="9">                         go (y<span class="fu">:</span>xs)</a>
+<a class="sourceLine" id="cb267-10" title="10">        go (x<span class="fu">:</span>xs) <span class="fu">=</span> go xs</a>
+<a class="sourceLine" id="cb267-11" title="11">        go [] <span class="fu">=</span> <span class="fu">return</span> ()</a></code></pre></div>
+<div class="sourceCode" id="cb268"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb268-1" title="1">valuesAfterZero [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">0</span>,<span class="dv">4</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb268-2" title="2">  <span class="fu">==&gt;</span> ((),[<span class="dv">6</span>,<span class="dv">0</span>,<span class="dv">5</span>,<span class="dv">4</span>,<span class="dv">1</span>])</a></code></pre></div>
 <h2 id="the-return-of-mapm"><span class="header-section-number">13.9</span> The Return of <code>mapM</code></h2>
 <p>The control structures from the IO lecture work in <em>all monads</em>. Here are their real types.</p>
-<div class="sourceCode" id="cb269"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb269-1" data-line-number="1"><span class="ot">when ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()        <span class="co">-- conditional operation</span></a>
-<a class="sourceLine" id="cb269-2" data-line-number="2"><span class="ot">unless ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()      <span class="co">-- same, but condition is flipped</span></a>
-<a class="sourceLine" id="cb269-3" data-line-number="3"><span class="ot">replicateM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m [a]   <span class="co">-- do something many times</span></a>
-<a class="sourceLine" id="cb269-4" data-line-number="4"><span class="ot">replicateM_ ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m ()   <span class="co">-- same, but ignore the results</span></a>
-<a class="sourceLine" id="cb269-5" data-line-number="5">mapM<span class="ot"> ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m [b]  <span class="co">-- do something on a list&#39;s elements</span></a>
-<a class="sourceLine" id="cb269-6" data-line-number="6">mapM_<span class="ot"> ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m ()  <span class="co">-- same, but ignore the results</span></a>
-<a class="sourceLine" id="cb269-7" data-line-number="7"><span class="ot">forM  ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m [b] <span class="co">-- mapM but arguments reversed</span></a>
-<a class="sourceLine" id="cb269-8" data-line-number="8"><span class="ot">forM_ ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m ()  <span class="co">-- same, but ignore the results</span></a></code></pre></div>
+<div class="sourceCode" id="cb269"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb269-1" title="1"><span class="ot">when ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()        <span class="co">-- conditional operation</span></a>
+<a class="sourceLine" id="cb269-2" title="2"><span class="ot">unless ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()      <span class="co">-- same, but condition is flipped</span></a>
+<a class="sourceLine" id="cb269-3" title="3"><span class="ot">replicateM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m [a]   <span class="co">-- do something many times</span></a>
+<a class="sourceLine" id="cb269-4" title="4"><span class="ot">replicateM_ ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m ()   <span class="co">-- same, but ignore the results</span></a>
+<a class="sourceLine" id="cb269-5" title="5"><span class="fu">mapM</span><span class="ot"> ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m [b]  <span class="co">-- do something on a list&#39;s elements</span></a>
+<a class="sourceLine" id="cb269-6" title="6"><span class="fu">mapM_</span><span class="ot"> ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m ()  <span class="co">-- same, but ignore the results</span></a>
+<a class="sourceLine" id="cb269-7" title="7"><span class="ot">forM  ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m [b] <span class="co">-- mapM but arguments reversed</span></a>
+<a class="sourceLine" id="cb269-8" title="8"><span class="ot">forM_ ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> m ()  <span class="co">-- same, but ignore the results</span></a></code></pre></div>
 <p>As we can see here, we can use <code>mapM</code> over all of the monads we’ve met so far:</p>
-<div class="sourceCode" id="cb270"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb270-1" data-line-number="1">mapM (\x <span class="ot">-&gt;</span> <span class="kw">if</span> (x<span class="fu">&gt;</span><span class="dv">0</span>) <span class="kw">then</span> <span class="dt">Just</span> (x<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dt">Just</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb270-2" data-line-number="2">mapM (\x <span class="ot">-&gt;</span> <span class="kw">if</span> (x<span class="fu">&gt;</span><span class="dv">0</span>) <span class="kw">then</span> <span class="dt">Just</span> (x<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb270-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb270-4" data-line-number="4">mapM (\x <span class="ot">-&gt;</span> msg <span class="st">&quot;increment&quot;</span> <span class="fu">&gt;&gt;</span> msg (show x) <span class="fu">&gt;&gt;</span> return (x<span class="fu">+</span><span class="dv">1</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb270-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;1&quot;</span>,<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;3&quot;</span>] [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb270-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb270-7" data-line-number="7">runState (mapM (\x <span class="ot">-&gt;</span> modify (x<span class="fu">+</span>) <span class="fu">&gt;&gt;</span> return (x<span class="fu">+</span><span class="dv">1</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]) <span class="dv">0</span></a>
-<a class="sourceLine" id="cb270-8" data-line-number="8">  <span class="fu">==&gt;</span> ([<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>],<span class="dv">6</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb270"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb270-1" title="1"><span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> (x<span class="fu">&gt;</span><span class="dv">0</span>) <span class="kw">then</span> <span class="dt">Just</span> (x<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dt">Just</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb270-2" title="2"><span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> (x<span class="fu">&gt;</span><span class="dv">0</span>) <span class="kw">then</span> <span class="dt">Just</span> (x<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb270-3" title="3"></a>
+<a class="sourceLine" id="cb270-4" title="4"><span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> msg <span class="st">&quot;increment&quot;</span> <span class="fu">&gt;&gt;</span> msg (<span class="fu">show</span> x) <span class="fu">&gt;&gt;</span> <span class="fu">return</span> (x<span class="fu">+</span><span class="dv">1</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb270-5" title="5">  <span class="fu">==&gt;</span> <span class="dt">Logger</span> [<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;1&quot;</span>,<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;2&quot;</span>,<span class="st">&quot;increment&quot;</span>,<span class="st">&quot;3&quot;</span>] [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb270-6" title="6"></a>
+<a class="sourceLine" id="cb270-7" title="7">runState (<span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> modify (x<span class="fu">+</span>) <span class="fu">&gt;&gt;</span> <span class="fu">return</span> (x<span class="fu">+</span><span class="dv">1</span>)) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]) <span class="dv">0</span></a>
+<a class="sourceLine" id="cb270-8" title="8">  <span class="fu">==&gt;</span> ([<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>],<span class="dv">6</span>)</a></code></pre></div>
 <p>Some more examples:</p>
-<div class="sourceCode" id="cb271"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb271-1" data-line-number="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
-<a class="sourceLine" id="cb271-2" data-line-number="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb271-3" data-line-number="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb271-4" data-line-number="4"><span class="ot">firsts ::</span> [[a]] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
-<a class="sourceLine" id="cb271-5" data-line-number="5">firsts xs <span class="fu">=</span> forM xs safeHead</a></code></pre></div>
-<div class="sourceCode" id="cb272"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb272-1" data-line-number="1">firsts [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">6</span>]] <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
-<a class="sourceLine" id="cb272-2" data-line-number="2">firsts [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">6</span>]]    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
-<div class="sourceCode" id="cb273"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb273-1" data-line-number="1"><span class="co">-- an abbreviated version of an example from the last section</span></a>
-<a class="sourceLine" id="cb273-2" data-line-number="2"><span class="ot">findLargest ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> a ()</a>
-<a class="sourceLine" id="cb273-3" data-line-number="3">findLargest xs <span class="fu">=</span> mapM_ update xs</a>
-<a class="sourceLine" id="cb273-4" data-line-number="4">  <span class="kw">where</span> update x <span class="fu">=</span> modify (\y <span class="ot">-&gt;</span> max x y)</a></code></pre></div>
-<div class="sourceCode" id="cb274"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb274-1" data-line-number="1">runState (findLargest [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">7</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb275"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb275-1" data-line-number="1"><span class="kw">let</span> increment <span class="fu">=</span> modify (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">&gt;&gt;</span> get</a>
-<a class="sourceLine" id="cb275-2" data-line-number="2">    ops <span class="fu">=</span> replicateM <span class="dv">4</span> increment</a>
-<a class="sourceLine" id="cb275-3" data-line-number="3"><span class="kw">in</span> runState ops <span class="dv">0</span></a>
-<a class="sourceLine" id="cb275-4" data-line-number="4">  <span class="fu">==&gt;</span> ([<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>],<span class="dv">4</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb271"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb271-1" title="1"><span class="ot">safeHead ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> a</a>
+<a class="sourceLine" id="cb271-2" title="2">safeHead [] <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb271-3" title="3">safeHead (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb271-4" title="4"><span class="ot">firsts ::</span> [[a]] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> [a]</a>
+<a class="sourceLine" id="cb271-5" title="5">firsts xs <span class="fu">=</span> forM xs safeHead</a></code></pre></div>
+<div class="sourceCode" id="cb272"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb272-1" title="1">firsts [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[<span class="dv">4</span>,<span class="dv">5</span>],[<span class="dv">6</span>]] <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">6</span>]</a>
+<a class="sourceLine" id="cb272-2" title="2">firsts [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>],[],[<span class="dv">6</span>]]    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb273"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb273-1" title="1"><span class="co">-- an abbreviated version of an example from the last section</span></a>
+<a class="sourceLine" id="cb273-2" title="2"><span class="ot">findLargest ::</span> <span class="dt">Ord</span> a <span class="ot">=&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> a ()</a>
+<a class="sourceLine" id="cb273-3" title="3">findLargest xs <span class="fu">=</span> <span class="fu">mapM_</span> update xs</a>
+<a class="sourceLine" id="cb273-4" title="4">  <span class="kw">where</span> update x <span class="fu">=</span> modify (\y <span class="ot">-&gt;</span> <span class="fu">max</span> x y)</a></code></pre></div>
+<div class="sourceCode" id="cb274"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb274-1" title="1">runState (findLargest [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">7</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">7</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb275"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb275-1" title="1"><span class="kw">let</span> increment <span class="fu">=</span> modify (<span class="fu">+</span><span class="dv">1</span>) <span class="fu">&gt;&gt;</span> get</a>
+<a class="sourceLine" id="cb275-2" title="2">    ops <span class="fu">=</span> replicateM <span class="dv">4</span> increment</a>
+<a class="sourceLine" id="cb275-3" title="3"><span class="kw">in</span> runState ops <span class="dv">0</span></a>
+<a class="sourceLine" id="cb275-4" title="4">  <span class="fu">==&gt;</span> ([<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>],<span class="dv">4</span>)</a></code></pre></div>
 <p>Here’s <code>filter</code> reimplemented using the <code>State</code> monad:</p>
-<div class="sourceCode" id="cb276"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb276-1" data-line-number="1"><span class="ot">rememberElements ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
-<a class="sourceLine" id="cb276-2" data-line-number="2">rememberElements f xs <span class="fu">=</span> mapM_ maybePut xs</a>
-<a class="sourceLine" id="cb276-3" data-line-number="3">  <span class="kw">where</span> maybePut x <span class="fu">=</span> when (f x) (modify (<span class="fu">++</span>[x]))</a>
-<a class="sourceLine" id="cb276-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb276-5" data-line-number="5"><span class="ot">sfilter ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb276-6" data-line-number="6">sfilter f xs <span class="fu">=</span> finalState</a>
-<a class="sourceLine" id="cb276-7" data-line-number="7">  <span class="kw">where</span> (_, finalState) <span class="fu">=</span> runState (rememberElements f xs) []</a></code></pre></div>
-<div class="sourceCode" id="cb277"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb277-1" data-line-number="1">sfilter even [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]</a>
-<a class="sourceLine" id="cb277-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb276"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb276-1" title="1"><span class="ot">rememberElements ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">State</span> [a] ()</a>
+<a class="sourceLine" id="cb276-2" title="2">rememberElements f xs <span class="fu">=</span> <span class="fu">mapM_</span> maybePut xs</a>
+<a class="sourceLine" id="cb276-3" title="3">  <span class="kw">where</span> maybePut x <span class="fu">=</span> when (f x) (modify (<span class="fu">++</span>[x]))</a>
+<a class="sourceLine" id="cb276-4" title="4"></a>
+<a class="sourceLine" id="cb276-5" title="5"><span class="ot">sfilter ::</span> (a <span class="ot">-&gt;</span> <span class="dt">Bool</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb276-6" title="6">sfilter f xs <span class="fu">=</span> finalState</a>
+<a class="sourceLine" id="cb276-7" title="7">  <span class="kw">where</span> (_, finalState) <span class="fu">=</span> runState (rememberElements f xs) []</a></code></pre></div>
+<div class="sourceCode" id="cb277"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb277-1" title="1">sfilter <span class="fu">even</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>]</a>
+<a class="sourceLine" id="cb277-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">4</span>]</a></code></pre></div>
 <p>We can write our own operations that work for all monads. This is made possible by type classes, as we’ve seen before. If you only use monad operations like <code>return</code> and do-notation, the type system will infer a generic type for your function.</p>
-<div class="sourceCode" id="cb278"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb278-1" data-line-number="1">mywhen b op <span class="fu">=</span> <span class="kw">if</span> b <span class="kw">then</span> op <span class="kw">else</span> return ()</a>
-<a class="sourceLine" id="cb278-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb278-3" data-line-number="3">mymapM_ op [] <span class="fu">=</span> return ()</a>
-<a class="sourceLine" id="cb278-4" data-line-number="4">mymapM_ op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> op x</a>
-<a class="sourceLine" id="cb278-5" data-line-number="5">                       mymapM_ op xs</a></code></pre></div>
-<div class="sourceCode" id="cb279"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb279-1" data-line-number="1"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>t mywhen</a>
-<a class="sourceLine" id="cb279-2" data-line-number="2"><span class="ot">mywhen ::</span> (<span class="dt">Monad</span> m) <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()</a>
-<a class="sourceLine" id="cb279-3" data-line-number="3"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>t mymapM_</a>
-<a class="sourceLine" id="cb279-4" data-line-number="4"><span class="ot">mymapM_ ::</span> (<span class="dt">Monad</span> m) <span class="ot">=&gt;</span> (t <span class="ot">-&gt;</span> m a) <span class="ot">-&gt;</span> [t] <span class="ot">-&gt;</span> m ()</a></code></pre></div>
+<div class="sourceCode" id="cb278"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb278-1" title="1">mywhen b op <span class="fu">=</span> <span class="kw">if</span> b <span class="kw">then</span> op <span class="kw">else</span> <span class="fu">return</span> ()</a>
+<a class="sourceLine" id="cb278-2" title="2"></a>
+<a class="sourceLine" id="cb278-3" title="3">mymapM_ op [] <span class="fu">=</span> <span class="fu">return</span> ()</a>
+<a class="sourceLine" id="cb278-4" title="4">mymapM_ op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> op x</a>
+<a class="sourceLine" id="cb278-5" title="5">                       mymapM_ op xs</a></code></pre></div>
+<div class="sourceCode" id="cb279"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb279-1" title="1"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>t mywhen</a>
+<a class="sourceLine" id="cb279-2" title="2"><span class="ot">mywhen ::</span> (<span class="dt">Monad</span> m) <span class="ot">=&gt;</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> m () <span class="ot">-&gt;</span> m ()</a>
+<a class="sourceLine" id="cb279-3" title="3"><span class="fu">*</span><span class="dt">Main</span><span class="fu">&gt;</span> <span class="fu">:</span>t mymapM_</a>
+<a class="sourceLine" id="cb279-4" title="4"><span class="ot">mymapM_ ::</span> (<span class="dt">Monad</span> m) <span class="ot">=&gt;</span> (t <span class="ot">-&gt;</span> m a) <span class="ot">-&gt;</span> [t] <span class="ot">-&gt;</span> m ()</a></code></pre></div>
 <p>We can use these generic operations in each of our example monads:</p>
-<div class="sourceCode" id="cb280"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb280-1" data-line-number="1"><span class="ot">perhapsDecrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb280-2" data-line-number="2">perhapsDecrease x <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb280-3" data-line-number="3">  mywhen (x<span class="fu">&lt;=</span><span class="dv">0</span>) <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb280-4" data-line-number="4">  return (x<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
-<div class="sourceCode" id="cb281"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb281-1" data-line-number="1">perhapsDecrease <span class="dv">2</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb281-2" data-line-number="2">perhapsDecrease <span class="dv">0</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a></code></pre></div>
-<div class="sourceCode" id="cb282"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb282-1" data-line-number="1"><span class="ot">search ::</span> (<span class="dt">Show</span> a, <span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
-<a class="sourceLine" id="cb282-2" data-line-number="2">search x ys <span class="fu">=</span> mymapM_ look ys</a>
-<a class="sourceLine" id="cb282-3" data-line-number="3">  <span class="kw">where</span> look y <span class="fu">=</span> mywhen (x<span class="fu">==</span>y) (msg (<span class="st">&quot;Found &quot;</span><span class="fu">++</span>show y))</a></code></pre></div>
-<div class="sourceCode" id="cb283"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb283-1" data-line-number="1">search <span class="dv">3</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Logger</span> [<span class="st">&quot;Found 3&quot;</span>,<span class="st">&quot;Found 3&quot;</span>] ()</a></code></pre></div>
-<div class="sourceCode" id="cb284"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb284-1" data-line-number="1"><span class="ot">sumPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">State</span> <span class="dt">Int</span> ()</a>
-<a class="sourceLine" id="cb284-2" data-line-number="2">sumPositive xs <span class="fu">=</span> mymapM_ f xs</a>
-<a class="sourceLine" id="cb284-3" data-line-number="3">  <span class="kw">where</span> f x <span class="fu">=</span> when (x<span class="fu">&gt;</span><span class="dv">0</span>) (modify (x<span class="fu">+</span>))</a></code></pre></div>
-<div class="sourceCode" id="cb285"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb285-1" data-line-number="1">runState (sumPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">2</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">6</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb280"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb280-1" title="1"><span class="ot">perhapsDecrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb280-2" title="2">perhapsDecrease x <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb280-3" title="3">  mywhen (x<span class="fu">&lt;=</span><span class="dv">0</span>) <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb280-4" title="4">  <span class="fu">return</span> (x<span class="fu">-</span><span class="dv">1</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb281"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb281-1" title="1">perhapsDecrease <span class="dv">2</span>  <span class="fu">==&gt;</span>  <span class="dt">Just</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb281-2" title="2">perhapsDecrease <span class="dv">0</span>  <span class="fu">==&gt;</span>  <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb282"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb282-1" title="1"><span class="ot">search ::</span> (<span class="dt">Show</span> a, <span class="dt">Eq</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">Logger</span> ()</a>
+<a class="sourceLine" id="cb282-2" title="2">search x ys <span class="fu">=</span> mymapM_ look ys</a>
+<a class="sourceLine" id="cb282-3" title="3">  <span class="kw">where</span> look y <span class="fu">=</span> mywhen (x<span class="fu">==</span>y) (msg (<span class="st">&quot;Found &quot;</span><span class="fu">++show</span> y))</a></code></pre></div>
+<div class="sourceCode" id="cb283"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb283-1" title="1">search <span class="dv">3</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">3</span>,<span class="dv">2</span>]  <span class="fu">==&gt;</span>  <span class="dt">Logger</span> [<span class="st">&quot;Found 3&quot;</span>,<span class="st">&quot;Found 3&quot;</span>] ()</a></code></pre></div>
+<div class="sourceCode" id="cb284"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb284-1" title="1"><span class="ot">sumPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">State</span> <span class="dt">Int</span> ()</a>
+<a class="sourceLine" id="cb284-2" title="2">sumPositive xs <span class="fu">=</span> mymapM_ f xs</a>
+<a class="sourceLine" id="cb284-3" title="3">  <span class="kw">where</span> f x <span class="fu">=</span> when (x<span class="fu">&gt;</span><span class="dv">0</span>) (modify (x<span class="fu">+</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb285"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb285-1" title="1">runState (sumPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">2</span>,<span class="dv">3</span>]) <span class="dv">0</span>  <span class="fu">==&gt;</span>  ((),<span class="dv">6</span>)</a></code></pre></div>
 <h2 id="monads-are-functors"><span class="header-section-number">13.10</span> Monads are Functors</h2>
 <p>One useful operation hasn’t yet been introduced: <code>liftM</code>.</p>
-<div class="sourceCode" id="cb286"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb286-1" data-line-number="1"><span class="ot">liftM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m b</a>
-<a class="sourceLine" id="cb286-2" data-line-number="2">liftM f op <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op</a>
-<a class="sourceLine" id="cb286-3" data-line-number="3">                return (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb286"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb286-1" title="1"><span class="ot">liftM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> m a <span class="ot">-&gt;</span> m b</a>
+<a class="sourceLine" id="cb286-2" title="2">liftM f op <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op</a>
+<a class="sourceLine" id="cb286-3" title="3">                <span class="fu">return</span> (f x)</a></code></pre></div>
 <p>The <code>liftM</code> operation makes it easy to write code with pure and monadic parts.</p>
-<div class="sourceCode" id="cb287"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb287-1" data-line-number="1">liftM negate (<span class="dt">Just</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb287-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="fu">-</span><span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb287-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb287-4" data-line-number="4">liftM sort <span class="fu">$</span> firsts [[<span class="dv">4</span>,<span class="dv">6</span>],[<span class="dv">2</span>,<span class="dv">1</span>,<span class="dv">0</span>],[<span class="dv">3</span>,<span class="dv">3</span>,<span class="dv">3</span>]]</a>
-<a class="sourceLine" id="cb287-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb287-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb287-7" data-line-number="7">runState (liftM negate get) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb287-8" data-line-number="8">  <span class="fu">==&gt;</span> (<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb287"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb287-1" title="1">liftM <span class="fu">negate</span> (<span class="dt">Just</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb287-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="fu">-</span><span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb287-3" title="3"></a>
+<a class="sourceLine" id="cb287-4" title="4">liftM <span class="fu">sort</span> <span class="fu">$</span> firsts [[<span class="dv">4</span>,<span class="dv">6</span>],[<span class="dv">2</span>,<span class="dv">1</span>,<span class="dv">0</span>],[<span class="dv">3</span>,<span class="dv">3</span>,<span class="dv">3</span>]]</a>
+<a class="sourceLine" id="cb287-5" title="5">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb287-6" title="6"></a>
+<a class="sourceLine" id="cb287-7" title="7">runState (liftM <span class="fu">negate</span> get) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb287-8" title="8">  <span class="fu">==&gt;</span> (<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>)</a></code></pre></div>
 <p>Does the type of <code>liftM</code> look familiar? It’s just like the type of <code>fmap</code>! In fact, it’s easy to define a functor instance for a monad: just set <code>fmap = liftM</code>. Since every <code>Monad</code> needs to be a <code>Functor</code> these days, modern Haskell style prefers <code>fmap</code> over <code>liftM</code>.</p>
-<div class="sourceCode" id="cb288"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb288-1" data-line-number="1">fmap<span class="ot"> ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
-<div class="sourceCode" id="cb289"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb289-1" data-line-number="1">fmap negate (<span class="dt">Just</span> <span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb289-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="fu">-</span><span class="dv">3</span>)</a>
-<a class="sourceLine" id="cb289-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb289-4" data-line-number="4">fmap sort <span class="fu">$</span> firsts [[<span class="dv">4</span>,<span class="dv">6</span>],[<span class="dv">2</span>,<span class="dv">1</span>,<span class="dv">0</span>],[<span class="dv">3</span>,<span class="dv">3</span>,<span class="dv">3</span>]]</a>
-<a class="sourceLine" id="cb289-5" data-line-number="5">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb289-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb289-7" data-line-number="7">runState (fmap negate get) <span class="dv">3</span></a>
-<a class="sourceLine" id="cb289-8" data-line-number="8">  <span class="fu">==&gt;</span> (<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb288"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb288-1" title="1"><span class="fu">fmap</span><span class="ot"> ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a<span class="ot">-&gt;</span>b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
+<div class="sourceCode" id="cb289"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb289-1" title="1"><span class="fu">fmap</span> <span class="fu">negate</span> (<span class="dt">Just</span> <span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb289-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="fu">-</span><span class="dv">3</span>)</a>
+<a class="sourceLine" id="cb289-3" title="3"></a>
+<a class="sourceLine" id="cb289-4" title="4"><span class="fu">fmap</span> <span class="fu">sort</span> <span class="fu">$</span> firsts [[<span class="dv">4</span>,<span class="dv">6</span>],[<span class="dv">2</span>,<span class="dv">1</span>,<span class="dv">0</span>],[<span class="dv">3</span>,<span class="dv">3</span>,<span class="dv">3</span>]]</a>
+<a class="sourceLine" id="cb289-5" title="5">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb289-6" title="6"></a>
+<a class="sourceLine" id="cb289-7" title="7">runState (<span class="fu">fmap</span> <span class="fu">negate</span> get) <span class="dv">3</span></a>
+<a class="sourceLine" id="cb289-8" title="8">  <span class="fu">==&gt;</span> (<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>)</a></code></pre></div>
 <h2 id="one-more-monad"><span class="header-section-number">13.11</span> One More Monad</h2>
 <p><em>The list monad</em> (that is, the <code>Monad</code> instance for <code>[]</code>) represents computations with <em>multiple return values</em>. It’s useful for searching through alternatives. Here’s a first example. For every <code>x</code> we produce both <code>x</code> and <code>-x</code>:</p>
-<div class="sourceCode" id="cb290"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb290-1" data-line-number="1">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> [<span class="fu">-</span>x,x]</a>
-<a class="sourceLine" id="cb290-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">1</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">2</span>,<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb290"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb290-1" title="1">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> [<span class="fu">-</span>x,x]</a>
+<a class="sourceLine" id="cb290-2" title="2">  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">1</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">2</span>,<span class="fu">-</span><span class="dv">3</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>We can filter out unsuitable values by produing an empty list:</p>
-<div class="sourceCode" id="cb291"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb291-1" data-line-number="1">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;</span><span class="dv">1</span> <span class="kw">then</span> [x] <span class="kw">else</span> []</a>
-<a class="sourceLine" id="cb291-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb291"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb291-1" title="1">[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&gt;&gt;=</span> \x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;</span><span class="dv">1</span> <span class="kw">then</span> [x] <span class="kw">else</span> []</a>
+<a class="sourceLine" id="cb291-2" title="2">  <span class="fu">==&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>]</a></code></pre></div>
 <p>If we’re using do-notation the list monad starts to look more like a looping construct:</p>
-<div class="sourceCode" id="cb292"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb292-1" data-line-number="1"><span class="kw">do</span> word <span class="ot">&lt;-</span> [<span class="st">&quot;Blue&quot;</span>, <span class="st">&quot;Green&quot;</span>]</a>
-<a class="sourceLine" id="cb292-2" data-line-number="2">   number <span class="ot">&lt;-</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb292-3" data-line-number="3">   return (word <span class="fu">++</span> show number)</a>
-<a class="sourceLine" id="cb292-4" data-line-number="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;Blue1&quot;</span>,<span class="st">&quot;Blue2&quot;</span>,<span class="st">&quot;Blue3&quot;</span>,<span class="st">&quot;Green1&quot;</span>,<span class="st">&quot;Green2&quot;</span>,<span class="st">&quot;Green3&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb292"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb292-1" title="1"><span class="kw">do</span> word <span class="ot">&lt;-</span> [<span class="st">&quot;Blue&quot;</span>, <span class="st">&quot;Green&quot;</span>]</a>
+<a class="sourceLine" id="cb292-2" title="2">   number <span class="ot">&lt;-</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb292-3" title="3">   <span class="fu">return</span> (word <span class="fu">++</span> <span class="fu">show</span> number)</a>
+<a class="sourceLine" id="cb292-4" title="4">  <span class="fu">==&gt;</span> [<span class="st">&quot;Blue1&quot;</span>,<span class="st">&quot;Blue2&quot;</span>,<span class="st">&quot;Blue3&quot;</span>,<span class="st">&quot;Green1&quot;</span>,<span class="st">&quot;Green2&quot;</span>,<span class="st">&quot;Green3&quot;</span>]</a></code></pre></div>
 <p>More interesting example: find all the pairs in a list that sum to <code>k</code>. (The same element twice counts as a pair.)</p>
-<div class="sourceCode" id="cb293"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb293-1" data-line-number="1"><span class="ot">findSum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb293-2" data-line-number="2">findSum xs k <span class="fu">=</span> <span class="kw">do</span> a <span class="ot">&lt;-</span> xs</a>
-<a class="sourceLine" id="cb293-3" data-line-number="3">                  b <span class="ot">&lt;-</span> xs</a>
-<a class="sourceLine" id="cb293-4" data-line-number="4">                  <span class="kw">if</span> (a<span class="fu">+</span>b<span class="fu">==</span>k) <span class="kw">then</span> [(a,b)] <span class="kw">else</span> []</a></code></pre></div>
-<div class="sourceCode" id="cb294"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb294-1" data-line-number="1">findSum [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>] <span class="dv">5</span></a>
-<a class="sourceLine" id="cb294-2" data-line-number="2">  <span class="fu">==&gt;</span> [(<span class="dv">1</span>,<span class="dv">4</span>),(<span class="dv">2</span>,<span class="dv">3</span>),(<span class="dv">3</span>,<span class="dv">2</span>),(<span class="dv">4</span>,<span class="dv">1</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb293"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb293-1" title="1"><span class="ot">findSum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb293-2" title="2">findSum xs k <span class="fu">=</span> <span class="kw">do</span> a <span class="ot">&lt;-</span> xs</a>
+<a class="sourceLine" id="cb293-3" title="3">                  b <span class="ot">&lt;-</span> xs</a>
+<a class="sourceLine" id="cb293-4" title="4">                  <span class="kw">if</span> (a<span class="fu">+</span>b<span class="fu">==</span>k) <span class="kw">then</span> [(a,b)] <span class="kw">else</span> []</a></code></pre></div>
+<div class="sourceCode" id="cb294"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb294-1" title="1">findSum [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>,<span class="dv">5</span>] <span class="dv">5</span></a>
+<a class="sourceLine" id="cb294-2" title="2">  <span class="fu">==&gt;</span> [(<span class="dv">1</span>,<span class="dv">4</span>),(<span class="dv">2</span>,<span class="dv">3</span>),(<span class="dv">3</span>,<span class="dv">2</span>),(<span class="dv">4</span>,<span class="dv">1</span>)]</a></code></pre></div>
 <p>A final, more complex example. We find all palindromes from a string using the list monad, and then find the longest one.</p>
-<div class="sourceCode" id="cb295"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb295-1" data-line-number="1"><span class="kw">import</span> <span class="dt">Data.List</span> (sortBy)</a>
-<a class="sourceLine" id="cb295-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb295-3" data-line-number="3"><span class="ot">substrings ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb295-4" data-line-number="4">substrings xs <span class="fu">=</span> <span class="kw">do</span> start <span class="ot">&lt;-</span> [<span class="dv">0</span><span class="fu">..</span>length xs <span class="fu">-</span> <span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb295-5" data-line-number="5">                   end <span class="ot">&lt;-</span> [start<span class="fu">+</span><span class="dv">1</span><span class="fu">..</span>length xs <span class="fu">-</span> <span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb295-6" data-line-number="6">                   return <span class="fu">$</span> drop start <span class="fu">$</span> take end <span class="fu">$</span> xs</a>
-<a class="sourceLine" id="cb295-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb295-8" data-line-number="8"><span class="ot">palindromesIn ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb295-9" data-line-number="9">palindromesIn xs <span class="fu">=</span> <span class="kw">do</span> s <span class="ot">&lt;-</span> substrings xs</a>
-<a class="sourceLine" id="cb295-10" data-line-number="10">                      <span class="kw">if</span> (s<span class="fu">==</span>reverse s) <span class="kw">then</span> return s <span class="kw">else</span> []</a>
-<a class="sourceLine" id="cb295-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb295-12" data-line-number="12">longestPalindrome xs <span class="fu">=</span> head <span class="fu">.</span> sortBy f <span class="fu">$</span> palindromesIn xs</a>
-<a class="sourceLine" id="cb295-13" data-line-number="13">  <span class="kw">where</span> f s s&#39; <span class="fu">=</span> compare (length s&#39;) (length s)  <span class="co">-- longer is smaller</span></a></code></pre></div>
-<div class="sourceCode" id="cb296"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb296-1" data-line-number="1">palindromesIn <span class="st">&quot;aabbacddcaca&quot;</span></a>
-<a class="sourceLine" id="cb296-2" data-line-number="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;a&quot;</span>,<span class="st">&quot;aa&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;abba&quot;</span>,<span class="st">&quot;b&quot;</span>,<span class="st">&quot;bb&quot;</span>,<span class="st">&quot;b&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;acddca&quot;</span>,<span class="st">&quot;c&quot;</span>,<span class="st">&quot;cddc&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;dd&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;c&quot;</span>,<span class="st">&quot;cac&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;c&quot;</span>]</a>
-<a class="sourceLine" id="cb296-3" data-line-number="3">longestPalindrome <span class="st">&quot;aabbacddcaca&quot;</span></a>
-<a class="sourceLine" id="cb296-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="st">&quot;acddca&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb295"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb295-1" title="1"><span class="kw">import</span> <span class="dt">Data.List</span> (sortBy)</a>
+<a class="sourceLine" id="cb295-2" title="2"></a>
+<a class="sourceLine" id="cb295-3" title="3"><span class="ot">substrings ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb295-4" title="4">substrings xs <span class="fu">=</span> <span class="kw">do</span> start <span class="ot">&lt;-</span> [<span class="dv">0</span><span class="fu">..length</span> xs <span class="fu">-</span> <span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb295-5" title="5">                   end <span class="ot">&lt;-</span> [start<span class="fu">+</span><span class="dv">1</span><span class="fu">..length</span> xs <span class="fu">-</span> <span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb295-6" title="6">                   <span class="fu">return</span> <span class="fu">$</span> <span class="fu">drop</span> start <span class="fu">$</span> <span class="fu">take</span> end <span class="fu">$</span> xs</a>
+<a class="sourceLine" id="cb295-7" title="7"></a>
+<a class="sourceLine" id="cb295-8" title="8"><span class="ot">palindromesIn ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb295-9" title="9">palindromesIn xs <span class="fu">=</span> <span class="kw">do</span> s <span class="ot">&lt;-</span> substrings xs</a>
+<a class="sourceLine" id="cb295-10" title="10">                      <span class="kw">if</span> (s<span class="fu">==reverse</span> s) <span class="kw">then</span> <span class="fu">return</span> s <span class="kw">else</span> []</a>
+<a class="sourceLine" id="cb295-11" title="11"></a>
+<a class="sourceLine" id="cb295-12" title="12">longestPalindrome xs <span class="fu">=</span> <span class="fu">head</span> <span class="fu">.</span> sortBy f <span class="fu">$</span> palindromesIn xs</a>
+<a class="sourceLine" id="cb295-13" title="13">  <span class="kw">where</span> f s s&#39; <span class="fu">=</span> <span class="fu">compare</span> (<span class="fu">length</span> s&#39;) (<span class="fu">length</span> s)  <span class="co">-- longer is smaller</span></a></code></pre></div>
+<div class="sourceCode" id="cb296"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb296-1" title="1">palindromesIn <span class="st">&quot;aabbacddcaca&quot;</span></a>
+<a class="sourceLine" id="cb296-2" title="2">  <span class="fu">==&gt;</span> [<span class="st">&quot;a&quot;</span>,<span class="st">&quot;aa&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;abba&quot;</span>,<span class="st">&quot;b&quot;</span>,<span class="st">&quot;bb&quot;</span>,<span class="st">&quot;b&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;acddca&quot;</span>,<span class="st">&quot;c&quot;</span>,<span class="st">&quot;cddc&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;dd&quot;</span>,<span class="st">&quot;d&quot;</span>,<span class="st">&quot;c&quot;</span>,<span class="st">&quot;cac&quot;</span>,<span class="st">&quot;a&quot;</span>,<span class="st">&quot;c&quot;</span>]</a>
+<a class="sourceLine" id="cb296-3" title="3">longestPalindrome <span class="st">&quot;aabbacddcaca&quot;</span></a>
+<a class="sourceLine" id="cb296-4" title="4">  <span class="fu">==&gt;</span> <span class="st">&quot;acddca&quot;</span></a></code></pre></div>
 <p>Here’s the surprisingly simple implementation of the list monad:</p>
-<div class="sourceCode" id="cb297"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb297-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Monad</span> [] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb297-2" data-line-number="2">  return x <span class="fu">=</span> [x]                  <span class="co">-- an operation that produces one value</span></a>
-<a class="sourceLine" id="cb297-3" data-line-number="3">  lis <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> concat (map f lis)  <span class="co">-- compute f for all values, combine the results</span></a></code></pre></div>
+<div class="sourceCode" id="cb297"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb297-1" title="1"><span class="kw">instance</span> <span class="dt">Monad</span> [] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb297-2" title="2">  <span class="fu">return</span> x <span class="fu">=</span> [x]                  <span class="co">-- an operation that produces one value</span></a>
+<a class="sourceLine" id="cb297-3" title="3">  lis <span class="fu">&gt;&gt;=</span> f <span class="fu">=</span> <span class="fu">concat</span> (<span class="fu">map</span> f lis)  <span class="co">-- compute f for all values, combine the results</span></a></code></pre></div>
 <p>We’ve actually seen the list monad previously in the guise of list comprehensions. Compare this reimplementation of <code>findSum</code> to the earlier one that uses <code>do</code>-notation.</p>
-<div class="sourceCode" id="cb298"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb298-1" data-line-number="1"><span class="ot">findSum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb298-2" data-line-number="2">findSum xs k <span class="fu">=</span> [(a,b) <span class="fu">|</span> a <span class="ot">&lt;-</span> xs, b <span class="ot">&lt;-</span> xs, a<span class="fu">+</span>b<span class="fu">==</span>k ]</a></code></pre></div>
+<div class="sourceCode" id="cb298"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb298-1" title="1"><span class="ot">findSum ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb298-2" title="2">findSum xs k <span class="fu">=</span> [(a,b) <span class="fu">|</span> a <span class="ot">&lt;-</span> xs, b <span class="ot">&lt;-</span> xs, a<span class="fu">+</span>b<span class="fu">==</span>k ]</a></code></pre></div>
 <h2 id="oh-right-io"><span class="header-section-number">13.12</span> Oh Right, IO</h2>
 <p>As you’ve probably guessed by now, <code>IO</code> is a monad. However the implementations of the <code>IO</code> type and <code>instance Monad IO</code> are compiler built-ins. You couldn’t implement the IO monad just using standard Haskell, unlike <code>Maybe</code> monad, <code>State</code> monad and other monads we’ve seen.</p>
 <p>However, true side effects fit the monad pattern just like <code>State</code> and <code>Maybe</code>. Just like with other monads, we’re separating the <em>pure definitions of operations</em> from the process of <em>running the operations</em>. As a bonus, you can use all the generic monad operations (<code>mapM</code> and friends) with IO.</p>
 <p>Here are some examples of writing IO using monad operations.</p>
-<div class="sourceCode" id="cb299"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb299-1" data-line-number="1"><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb299-2" data-line-number="2">printTwoThings <span class="fu">=</span> putStrLn <span class="st">&quot;One!&quot;</span> <span class="fu">&gt;&gt;</span> print <span class="dv">2</span></a>
-<a class="sourceLine" id="cb299-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb299-4" data-line-number="4"><span class="ot">echo ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb299-5" data-line-number="5">echo <span class="fu">=</span> getLine <span class="fu">&gt;&gt;=</span> putStrLn</a>
-<a class="sourceLine" id="cb299-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb299-7" data-line-number="7"><span class="ot">verboseEcho ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb299-8" data-line-number="8">verboseEcho <span class="fu">=</span> getLine <span class="fu">&gt;&gt;=</span> \s <span class="ot">-&gt;</span> putStrLn (<span class="st">&quot;You wrote: &quot;</span> <span class="fu">++</span> s)</a>
-<a class="sourceLine" id="cb299-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb299-10" data-line-number="10"><span class="ot">query ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb299-11" data-line-number="11">query question <span class="fu">=</span> putStrLn question <span class="fu">&gt;&gt;</span> getLine</a>
-<a class="sourceLine" id="cb299-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb299-13" data-line-number="13"><span class="ot">confirm ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb299-14" data-line-number="14">confirm question <span class="fu">=</span> putStrLn question <span class="fu">&gt;&gt;</span> fmap interpret getLine</a>
-<a class="sourceLine" id="cb299-15" data-line-number="15">    <span class="kw">where</span> interpret <span class="st">&quot;Y&quot;</span> <span class="fu">=</span> <span class="dt">True</span></a>
-<a class="sourceLine" id="cb299-16" data-line-number="16">          interpret _ <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
-<div class="sourceCode" id="cb300"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb300-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printTwoThings</a>
-<a class="sourceLine" id="cb300-2" data-line-number="2"><span class="dt">One</span><span class="fu">!</span></a>
-<a class="sourceLine" id="cb300-3" data-line-number="3"><span class="dv">2</span></a>
-<a class="sourceLine" id="cb300-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb300-5" data-line-number="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> verboseEcho</a>
-<a class="sourceLine" id="cb300-6" data-line-number="6"><span class="dt">The</span> <span class="dt">Iliad</span></a>
-<a class="sourceLine" id="cb300-7" data-line-number="7"><span class="dt">You</span> wrote<span class="fu">:</span> <span class="dt">The</span> <span class="dt">Iliad</span></a>
-<a class="sourceLine" id="cb300-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb300-9" data-line-number="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer <span class="ot">&lt;-</span> query <span class="st">&quot;Why am I here?&quot;</span></a>
-<a class="sourceLine" id="cb300-10" data-line-number="10"><span class="dt">Why</span> am <span class="dt">I</span> here<span class="fu">?</span></a>
-<a class="sourceLine" id="cb300-11" data-line-number="11"><span class="dt">Good</span> question<span class="fu">!</span></a>
-<a class="sourceLine" id="cb300-12" data-line-number="12"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer</a>
-<a class="sourceLine" id="cb300-13" data-line-number="13"><span class="st">&quot;Good question!&quot;</span></a>
-<a class="sourceLine" id="cb300-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb300-15" data-line-number="15"><span class="dt">Prelude</span><span class="fu">&gt;</span> b <span class="ot">&lt;-</span> confirm <span class="st">&quot;Fire warheads?&quot;</span></a>
-<a class="sourceLine" id="cb300-16" data-line-number="16"><span class="dt">Fire</span> warheads<span class="fu">?</span></a>
-<a class="sourceLine" id="cb300-17" data-line-number="17">no no no no</a>
-<a class="sourceLine" id="cb300-18" data-line-number="18"><span class="dt">Prelude</span><span class="fu">&gt;</span> b</a>
-<a class="sourceLine" id="cb300-19" data-line-number="19"><span class="dt">False</span></a>
-<a class="sourceLine" id="cb300-20" data-line-number="20"><span class="dt">Prelude</span><span class="fu">&gt;</span> b <span class="ot">&lt;-</span> confirm <span class="st">&quot;Make love, not war?&quot;</span></a>
-<a class="sourceLine" id="cb300-21" data-line-number="21"><span class="dt">Make</span> love, not war<span class="fu">?</span></a>
-<a class="sourceLine" id="cb300-22" data-line-number="22"><span class="dt">Y</span></a>
-<a class="sourceLine" id="cb300-23" data-line-number="23"><span class="dt">Prelude</span><span class="fu">&gt;</span> b</a>
-<a class="sourceLine" id="cb300-24" data-line-number="24"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb299"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb299-1" title="1"><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb299-2" title="2">printTwoThings <span class="fu">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;One!&quot;</span> <span class="fu">&gt;&gt;</span> <span class="fu">print</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb299-3" title="3"></a>
+<a class="sourceLine" id="cb299-4" title="4"><span class="ot">echo ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb299-5" title="5">echo <span class="fu">=</span> <span class="fu">getLine</span> <span class="fu">&gt;&gt;=</span> <span class="fu">putStrLn</span></a>
+<a class="sourceLine" id="cb299-6" title="6"></a>
+<a class="sourceLine" id="cb299-7" title="7"><span class="ot">verboseEcho ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb299-8" title="8">verboseEcho <span class="fu">=</span> <span class="fu">getLine</span> <span class="fu">&gt;&gt;=</span> \s <span class="ot">-&gt;</span> <span class="fu">putStrLn</span> (<span class="st">&quot;You wrote: &quot;</span> <span class="fu">++</span> s)</a>
+<a class="sourceLine" id="cb299-9" title="9"></a>
+<a class="sourceLine" id="cb299-10" title="10"><span class="ot">query ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb299-11" title="11">query question <span class="fu">=</span> <span class="fu">putStrLn</span> question <span class="fu">&gt;&gt;</span> <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb299-12" title="12"></a>
+<a class="sourceLine" id="cb299-13" title="13"><span class="ot">confirm ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb299-14" title="14">confirm question <span class="fu">=</span> <span class="fu">putStrLn</span> question <span class="fu">&gt;&gt;</span> <span class="fu">fmap</span> interpret <span class="fu">getLine</span></a>
+<a class="sourceLine" id="cb299-15" title="15">    <span class="kw">where</span> interpret <span class="st">&quot;Y&quot;</span> <span class="fu">=</span> <span class="dt">True</span></a>
+<a class="sourceLine" id="cb299-16" title="16">          interpret _ <span class="fu">=</span> <span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb300"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb300-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> printTwoThings</a>
+<a class="sourceLine" id="cb300-2" title="2"><span class="dt">One</span><span class="fu">!</span></a>
+<a class="sourceLine" id="cb300-3" title="3"><span class="dv">2</span></a>
+<a class="sourceLine" id="cb300-4" title="4"></a>
+<a class="sourceLine" id="cb300-5" title="5"><span class="dt">Prelude</span><span class="fu">&gt;</span> verboseEcho</a>
+<a class="sourceLine" id="cb300-6" title="6"><span class="dt">The</span> <span class="dt">Iliad</span></a>
+<a class="sourceLine" id="cb300-7" title="7"><span class="dt">You</span> wrote<span class="fu">:</span> <span class="dt">The</span> <span class="dt">Iliad</span></a>
+<a class="sourceLine" id="cb300-8" title="8"></a>
+<a class="sourceLine" id="cb300-9" title="9"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer <span class="ot">&lt;-</span> query <span class="st">&quot;Why am I here?&quot;</span></a>
+<a class="sourceLine" id="cb300-10" title="10"><span class="dt">Why</span> am <span class="dt">I</span> here<span class="fu">?</span></a>
+<a class="sourceLine" id="cb300-11" title="11"><span class="dt">Good</span> question<span class="fu">!</span></a>
+<a class="sourceLine" id="cb300-12" title="12"><span class="dt">Prelude</span><span class="fu">&gt;</span> answer</a>
+<a class="sourceLine" id="cb300-13" title="13"><span class="st">&quot;Good question!&quot;</span></a>
+<a class="sourceLine" id="cb300-14" title="14"></a>
+<a class="sourceLine" id="cb300-15" title="15"><span class="dt">Prelude</span><span class="fu">&gt;</span> b <span class="ot">&lt;-</span> confirm <span class="st">&quot;Fire warheads?&quot;</span></a>
+<a class="sourceLine" id="cb300-16" title="16"><span class="dt">Fire</span> warheads<span class="fu">?</span></a>
+<a class="sourceLine" id="cb300-17" title="17">no no no no</a>
+<a class="sourceLine" id="cb300-18" title="18"><span class="dt">Prelude</span><span class="fu">&gt;</span> b</a>
+<a class="sourceLine" id="cb300-19" title="19"><span class="dt">False</span></a>
+<a class="sourceLine" id="cb300-20" title="20"><span class="dt">Prelude</span><span class="fu">&gt;</span> b <span class="ot">&lt;-</span> confirm <span class="st">&quot;Make love, not war?&quot;</span></a>
+<a class="sourceLine" id="cb300-21" title="21"><span class="dt">Make</span> love, <span class="fu">not</span> war<span class="fu">?</span></a>
+<a class="sourceLine" id="cb300-22" title="22"><span class="dt">Y</span></a>
+<a class="sourceLine" id="cb300-23" title="23"><span class="dt">Prelude</span><span class="fu">&gt;</span> b</a>
+<a class="sourceLine" id="cb300-24" title="24"><span class="dt">True</span></a></code></pre></div>
 <h2 id="monads-in-other-languages"><span class="header-section-number">13.13</span> Monads in Other Languages</h2>
 <p>Once you’ve gotten familiar with the concept of a monad, you’ll start seeing monadlike things in other languages too. The most well-known examples of this are <em>Option types</em>, <em>Java Streams</em> and <em>JavaScript promises</em> . If you know these languages or concepts from before, you might find this section illuminating. If you don’t, feel free to skip this.</p>
 <h3 id="optionals"><span class="header-section-number">13.13.1</span> Optionals</h3>
@@ -3277,36 +3275,36 @@ this topic connects to equational reasoning discussed in chapter 10.
 <h3 id="streams"><span class="header-section-number">13.13.2</span> Streams</h3>
 <p><a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/stream/Stream.html">Java Streams</a> have a monadlike API too. Streams are about producing many values incrementally. Just like with Optional, the method <code>Stream.flatMap</code> lets us take a <code>Stream&lt;T&gt;</code>, combine it with a <code>Function&lt;T,Stream&lt;U&gt;&gt;</code> and get a <code>Stream&lt;U&gt;</code>.</p>
 <p>As an example, if <code>lines</code> is a <code>Stream&lt;String&gt;</code>, <code>words</code> takes a <code>String</code> and returns a <code>Stream&lt;String&gt;</code> and <code>readInt</code> takes a <code>String</code> and returns an <code>Integer</code>, we can write:</p>
-<div class="sourceCode" id="cb301"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb301-1" data-line-number="1">Stream&lt;<span class="bu">Integer</span>&gt; <span class="fu">parseNumbers</span>(Stream&lt;<span class="bu">String</span>&gt; lines) {</a>
-<a class="sourceLine" id="cb301-2" data-line-number="2">    <span class="kw">return</span> lines.<span class="fu">flatMap</span>(words).<span class="fu">map</span>(read);</a>
-<a class="sourceLine" id="cb301-3" data-line-number="3">}</a></code></pre></div>
+<div class="sourceCode" id="cb301"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb301-1" title="1">Stream&lt;<span class="bu">Integer</span>&gt; <span class="fu">parseNumbers</span>(Stream&lt;<span class="bu">String</span>&gt; lines) {</a>
+<a class="sourceLine" id="cb301-2" title="2">    <span class="kw">return</span> lines.<span class="fu">flatMap</span>(words).<span class="fu">map</span>(read);</a>
+<a class="sourceLine" id="cb301-3" title="3">}</a></code></pre></div>
 <p>This corresponds to the following Haskell list monad code:</p>
-<div class="sourceCode" id="cb302"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb302-1" data-line-number="1"><span class="ot">parseNumbers ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb302-2" data-line-number="2">parseNumbers strings <span class="fu">=</span> fmap read (strings <span class="fu">&gt;&gt;=</span> words)</a></code></pre></div>
-<div class="sourceCode" id="cb303"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb303-1" data-line-number="1">parseNumbers [<span class="st">&quot;123 456&quot;</span>,<span class="st">&quot;7 89&quot;</span>]  <span class="fu">==&gt;</span>  [<span class="dv">123</span>,<span class="dv">456</span>,<span class="dv">7</span>,<span class="dv">89</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb302"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb302-1" title="1"><span class="ot">parseNumbers ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb302-2" title="2">parseNumbers strings <span class="fu">=</span> <span class="fu">fmap</span> <span class="fu">read</span> (strings <span class="fu">&gt;&gt;=</span> <span class="fu">words</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb303"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb303-1" title="1">parseNumbers [<span class="st">&quot;123 456&quot;</span>,<span class="st">&quot;7 89&quot;</span>]  <span class="fu">==&gt;</span>  [<span class="dv">123</span>,<span class="dv">456</span>,<span class="dv">7</span>,<span class="dv">89</span>]</a></code></pre></div>
 <h3 id="promises"><span class="header-section-number">13.13.3</span> Promises</h3>
 <p>There is <a href="https://hackernoon.com/functional-javascript-functors-monads-and-promises-679ce2ab8abe">much</a> <a href="https://stackoverflow.com/questions/45712106/why-are-promises-monads">disagreement</a> about whether Promises in JavaScript <em>really</em> are monads or not. However, some similarities are obvious.</p>
 <p>First, consider the similarities between <code>Promise.then</code> and <code>&gt;&gt;=</code>. Both take an <em>operation</em> (promise or monadic operation), and combine it with a function that returns a new operation.</p>
-<div class="sourceCode" id="cb304"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb304-1" data-line-number="1"><span class="kw">function</span> <span class="at">concatPromises</span>(promise1<span class="op">,</span> promise2) <span class="op">{</span></a>
-<a class="sourceLine" id="cb304-2" data-line-number="2">  <span class="cf">return</span> <span class="va">promise1</span>.<span class="at">then</span>(value1 <span class="op">=&gt;</span> <span class="va">promise2</span>.<span class="at">then</span>(value2 <span class="op">=&gt;</span> value1<span class="op">+</span>value2))<span class="op">;</span></a>
-<a class="sourceLine" id="cb304-3" data-line-number="3"><span class="op">}</span></a></code></pre></div>
-<div class="sourceCode" id="cb305"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb305-1" data-line-number="1"><span class="op">&gt;&gt;</span> <span class="at">concatPromises</span>(<span class="va">Promise</span>.<span class="at">resolve</span>(<span class="st">&quot;abc&quot;</span>)<span class="op">,</span> <span class="va">Promise</span>.<span class="at">resolve</span>(<span class="st">&quot;def&quot;</span>)).<span class="at">then</span>(<span class="va">console</span>.<span class="at">log</span>)</a>
-<a class="sourceLine" id="cb305-2" data-line-number="2">abcdef</a></code></pre></div>
-<div class="sourceCode" id="cb306"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb306-1" data-line-number="1"><span class="ot">concatMonadic ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span></a>
-<a class="sourceLine" id="cb306-2" data-line-number="2">concatMonadic op1 op2 <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> (\value1 <span class="ot">-&gt;</span> op2 <span class="fu">&gt;&gt;=</span> (\value2 <span class="ot">-&gt;</span> return (value1<span class="fu">++</span>value2)))</a></code></pre></div>
-<div class="sourceCode" id="cb307"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb307-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> concatMonadic (<span class="dt">Just</span> <span class="st">&quot;abc&quot;</span>) (<span class="dt">Just</span> <span class="st">&quot;def&quot;</span>)</a>
-<a class="sourceLine" id="cb307-2" data-line-number="2"><span class="dt">Just</span> <span class="st">&quot;abcdef&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb304"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb304-1" title="1"><span class="kw">function</span> <span class="at">concatPromises</span>(promise1<span class="op">,</span> promise2) <span class="op">{</span></a>
+<a class="sourceLine" id="cb304-2" title="2">  <span class="cf">return</span> <span class="va">promise1</span>.<span class="at">then</span>(value1 <span class="kw">=&gt;</span> <span class="va">promise2</span>.<span class="at">then</span>(value2 <span class="kw">=&gt;</span> value1<span class="op">+</span>value2))<span class="op">;</span></a>
+<a class="sourceLine" id="cb304-3" title="3"><span class="op">}</span></a></code></pre></div>
+<div class="sourceCode" id="cb305"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb305-1" title="1"><span class="op">&gt;&gt;</span> <span class="at">concatPromises</span>(<span class="va">Promise</span>.<span class="at">resolve</span>(<span class="st">&quot;abc&quot;</span>)<span class="op">,</span> <span class="va">Promise</span>.<span class="at">resolve</span>(<span class="st">&quot;def&quot;</span>)).<span class="at">then</span>(<span class="va">console</span>.<span class="at">log</span>)</a>
+<a class="sourceLine" id="cb305-2" title="2">abcdef</a></code></pre></div>
+<div class="sourceCode" id="cb306"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb306-1" title="1"><span class="ot">concatMonadic ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span></a>
+<a class="sourceLine" id="cb306-2" title="2">concatMonadic op1 op2 <span class="fu">=</span> op1 <span class="fu">&gt;&gt;=</span> (\value1 <span class="ot">-&gt;</span> op2 <span class="fu">&gt;&gt;=</span> (\value2 <span class="ot">-&gt;</span> <span class="fu">return</span> (value1<span class="fu">++</span>value2)))</a></code></pre></div>
+<div class="sourceCode" id="cb307"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb307-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> concatMonadic (<span class="dt">Just</span> <span class="st">&quot;abc&quot;</span>) (<span class="dt">Just</span> <span class="st">&quot;def&quot;</span>)</a>
+<a class="sourceLine" id="cb307-2" title="2"><span class="dt">Just</span> <span class="st">&quot;abcdef&quot;</span></a></code></pre></div>
 <p>Next, let’s consider the similarities between async/await and do-notation. Both are nicer syntaxes for working with the raw <code>Promise.then</code> or <code>&gt;&gt;=</code> mechanisms. We reimplement <code>concatPromises</code> using async/await, and <code>concatMonadic</code> using do-notation. Their behaviour stays the same.</p>
-<div class="sourceCode" id="cb308"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb308-1" data-line-number="1">async <span class="kw">function</span> <span class="at">concatPromises</span>(promise1<span class="op">,</span> promise2) <span class="op">{</span></a>
-<a class="sourceLine" id="cb308-2" data-line-number="2">  <span class="kw">let</span> value1 <span class="op">=</span> await promise1<span class="op">;</span></a>
-<a class="sourceLine" id="cb308-3" data-line-number="3">  <span class="kw">let</span> value2 <span class="op">=</span> await promise2<span class="op">;</span></a>
-<a class="sourceLine" id="cb308-4" data-line-number="4">  <span class="cf">return</span> value1<span class="op">+</span>value2<span class="op">;</span></a>
-<a class="sourceLine" id="cb308-5" data-line-number="5"><span class="op">}</span></a></code></pre></div>
-<div class="sourceCode" id="cb309"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb309-1" data-line-number="1"><span class="ot">concatMonadic ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span></a>
-<a class="sourceLine" id="cb309-2" data-line-number="2">concatMonadic op1 op2 <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb309-3" data-line-number="3">  value1 <span class="ot">&lt;-</span> op1</a>
-<a class="sourceLine" id="cb309-4" data-line-number="4">  value2 <span class="ot">&lt;-</span> op2</a>
-<a class="sourceLine" id="cb309-5" data-line-number="5">  return (value1<span class="fu">++</span>value2)</a></code></pre></div>
+<div class="sourceCode" id="cb308"><pre class="sourceCode javascript"><code class="sourceCode javascript"><a class="sourceLine" id="cb308-1" title="1"><span class="kw">async</span> <span class="kw">function</span> <span class="at">concatPromises</span>(promise1<span class="op">,</span> promise2) <span class="op">{</span></a>
+<a class="sourceLine" id="cb308-2" title="2">  <span class="kw">let</span> value1 <span class="op">=</span> <span class="cf">await</span> promise1<span class="op">;</span></a>
+<a class="sourceLine" id="cb308-3" title="3">  <span class="kw">let</span> value2 <span class="op">=</span> <span class="cf">await</span> promise2<span class="op">;</span></a>
+<a class="sourceLine" id="cb308-4" title="4">  <span class="cf">return</span> value1<span class="op">+</span>value2<span class="op">;</span></a>
+<a class="sourceLine" id="cb308-5" title="5"><span class="op">}</span></a></code></pre></div>
+<div class="sourceCode" id="cb309"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb309-1" title="1"><span class="ot">concatMonadic ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span> <span class="ot">-&gt;</span> m <span class="dt">String</span></a>
+<a class="sourceLine" id="cb309-2" title="2">concatMonadic op1 op2 <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb309-3" title="3">  value1 <span class="ot">&lt;-</span> op1</a>
+<a class="sourceLine" id="cb309-4" title="4">  value2 <span class="ot">&lt;-</span> op2</a>
+<a class="sourceLine" id="cb309-5" title="5">  <span class="fu">return</span> (value1<span class="fu">++</span>value2)</a></code></pre></div>
 <h2 id="monads-wrap-up"><span class="header-section-number">13.14</span> Monads: Wrap-up</h2>
 <ul>
 <li>The <code>Monad</code> type class is a way to represent different ways of <em>executing recipes</em>
@@ -3348,9 +3346,9 @@ this topic connects to equational reasoning discussed in chapter 10.
 </ul>
 <h2 id="quiz-4"><span class="header-section-number">13.16</span> Quiz</h2>
 <p>What is the expression equivalent to the following do block?</p>
-<div class="sourceCode" id="cb310"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb310-1" data-line-number="1"><span class="kw">do</span> y <span class="ot">&lt;-</span> z</a>
-<a class="sourceLine" id="cb310-2" data-line-number="2">   s y</a>
-<a class="sourceLine" id="cb310-3" data-line-number="3">   return (f y)</a></code></pre></div>
+<div class="sourceCode" id="cb310"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb310-1" title="1"><span class="kw">do</span> y <span class="ot">&lt;-</span> z</a>
+<a class="sourceLine" id="cb310-2" title="2">   s y</a>
+<a class="sourceLine" id="cb310-3" title="3">   <span class="fu">return</span> (f y)</a></code></pre></div>
 <ol class="quiz">
 <li>
 <code>z &gt;&gt; \y -&gt; s y &gt;&gt; return (f y)</code>
@@ -3429,124 +3427,124 @@ None of the above
 <p>All of these types (<code>Text</code> and <code>ByteString</code>, strict and lazy) offer <code>pack</code> and <code>unpack</code> functions for converting from and to plain <code>String</code>s. The types also come with specialized versions of familiar list functions like <code>reverse</code>, <code>take</code>, <code>map</code> and so on.</p>
 <h3 id="examples-with-text"><span class="header-section-number">14.1.1</span> Examples with <code>Text</code></h3>
 <p>Let’s go through a short GHCi session demonstrating the use of <code>Data.Text</code>. As <a href="https://hackage.haskell.org/package/text-1.2.4.1/docs/Data-Text.html">the documentation</a> says, the <code>Data.Text</code> module is designed to be imported <em>qualified</em>. We can convert a <code>String</code> into a <code>Text</code> with the function <code>T.pack</code>. Note how a value of type <code>Text</code> gets printed just like a <code>String</code>.</p>
-<div class="sourceCode" id="cb311"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb311-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
-<a class="sourceLine" id="cb311-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.pack</a>
-<a class="sourceLine" id="cb311-3" data-line-number="3">T.pack<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
-<a class="sourceLine" id="cb311-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> phrase <span class="fu">=</span> T.pack <span class="st">&quot;brevity is the soul of wit&quot;</span></a>
-<a class="sourceLine" id="cb311-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t phrase</a>
-<a class="sourceLine" id="cb311-6" data-line-number="6"><span class="ot">phrase ::</span> <span class="dt">T.Text</span></a>
-<a class="sourceLine" id="cb311-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> phrase</a>
-<a class="sourceLine" id="cb311-8" data-line-number="8"><span class="st">&quot;brevity is the soul of wit&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb311"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb311-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
+<a class="sourceLine" id="cb311-2" title="2"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.pack</a>
+<a class="sourceLine" id="cb311-3" title="3">T.pack<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
+<a class="sourceLine" id="cb311-4" title="4"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> phrase <span class="fu">=</span> T.pack <span class="st">&quot;brevity is the soul of wit&quot;</span></a>
+<a class="sourceLine" id="cb311-5" title="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t phrase</a>
+<a class="sourceLine" id="cb311-6" title="6"><span class="ot">phrase ::</span> <span class="dt">T.Text</span></a>
+<a class="sourceLine" id="cb311-7" title="7"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> phrase</a>
+<a class="sourceLine" id="cb311-8" title="8"><span class="st">&quot;brevity is the soul of wit&quot;</span></a></code></pre></div>
 <p>We can use the functions from <code>Data.Text</code> to operate on values of <code>Text</code>. Many of these are named like their counterparts for <code>String</code>s or lists from <code>Prelude</code>.</p>
-<div class="sourceCode" id="cb312"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb312-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.length</a>
-<a class="sourceLine" id="cb312-2" data-line-number="2">T.length<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb312-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.length phrase</a>
-<a class="sourceLine" id="cb312-4" data-line-number="4"><span class="dv">26</span></a>
-<a class="sourceLine" id="cb312-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.head phrase</a>
-<a class="sourceLine" id="cb312-6" data-line-number="6"><span class="ch">&#39;b&#39;</span></a>
-<a class="sourceLine" id="cb312-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.take <span class="dv">4</span> phrase</a>
-<a class="sourceLine" id="cb312-8" data-line-number="8"><span class="st">&quot;brev&quot;</span></a>
-<a class="sourceLine" id="cb312-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.words</a>
-<a class="sourceLine" id="cb312-10" data-line-number="10">T.words<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> [<span class="dt">T.Text</span>]</a>
-<a class="sourceLine" id="cb312-11" data-line-number="11"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.words phrase</a>
-<a class="sourceLine" id="cb312-12" data-line-number="12">[<span class="st">&quot;brevity&quot;</span>,<span class="st">&quot;is&quot;</span>,<span class="st">&quot;the&quot;</span>,<span class="st">&quot;soul&quot;</span>,<span class="st">&quot;of&quot;</span>,<span class="st">&quot;wit&quot;</span>]</a>
-<a class="sourceLine" id="cb312-13" data-line-number="13"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.map</a>
-<a class="sourceLine" id="cb312-14" data-line-number="14">T.map<span class="ot"> ::</span> (<span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Char</span>) <span class="ot">-&gt;</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
-<a class="sourceLine" id="cb312-15" data-line-number="15"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.map (\c <span class="ot">-&gt;</span> <span class="kw">if</span> c<span class="fu">==</span><span class="ch">&#39;o&#39;</span> <span class="kw">then</span> <span class="ch">&#39;0&#39;</span> <span class="kw">else</span> c) phrase</a>
-<a class="sourceLine" id="cb312-16" data-line-number="16"><span class="st">&quot;brevity is the s0ul 0f wit&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb312"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb312-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.length</a>
+<a class="sourceLine" id="cb312-2" title="2">T.length<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb312-3" title="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.length phrase</a>
+<a class="sourceLine" id="cb312-4" title="4"><span class="dv">26</span></a>
+<a class="sourceLine" id="cb312-5" title="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.head phrase</a>
+<a class="sourceLine" id="cb312-6" title="6"><span class="ch">&#39;b&#39;</span></a>
+<a class="sourceLine" id="cb312-7" title="7"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.take <span class="dv">4</span> phrase</a>
+<a class="sourceLine" id="cb312-8" title="8"><span class="st">&quot;brev&quot;</span></a>
+<a class="sourceLine" id="cb312-9" title="9"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.words</a>
+<a class="sourceLine" id="cb312-10" title="10">T.words<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> [<span class="dt">T.Text</span>]</a>
+<a class="sourceLine" id="cb312-11" title="11"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.words phrase</a>
+<a class="sourceLine" id="cb312-12" title="12">[<span class="st">&quot;brevity&quot;</span>,<span class="st">&quot;is&quot;</span>,<span class="st">&quot;the&quot;</span>,<span class="st">&quot;soul&quot;</span>,<span class="st">&quot;of&quot;</span>,<span class="st">&quot;wit&quot;</span>]</a>
+<a class="sourceLine" id="cb312-13" title="13"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="fu">:</span>t T.map</a>
+<a class="sourceLine" id="cb312-14" title="14">T.map<span class="ot"> ::</span> (<span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Char</span>) <span class="ot">-&gt;</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
+<a class="sourceLine" id="cb312-15" title="15"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.map (\c <span class="ot">-&gt;</span> <span class="kw">if</span> c<span class="fu">==</span><span class="ch">&#39;o&#39;</span> <span class="kw">then</span> <span class="ch">&#39;0&#39;</span> <span class="kw">else</span> c) phrase</a>
+<a class="sourceLine" id="cb312-16" title="16"><span class="st">&quot;brevity is the s0ul 0f wit&quot;</span></a></code></pre></div>
 <p>A useful detail is that <code>Text</code> has a <code>Monoid</code> instance that glues <code>Text</code> values together. You can also use the functions <code>T.append</code> and <code>T.concat</code>.</p>
-<div class="sourceCode" id="cb313"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb313-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> phrase <span class="fu">&lt;&gt;</span> phrase</a>
-<a class="sourceLine" id="cb313-2" data-line-number="2"><span class="st">&quot;brevity is the soul of witbrevity is the soul of wit&quot;</span></a>
-<a class="sourceLine" id="cb313-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.append phrase phrase</a>
-<a class="sourceLine" id="cb313-4" data-line-number="4"><span class="st">&quot;brevity is the soul of witbrevity is the soul of wit&quot;</span></a>
-<a class="sourceLine" id="cb313-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.concat [phrase,phrase,phrase]</a>
-<a class="sourceLine" id="cb313-6" data-line-number="6"><span class="st">&quot;brevity is the soul of witbrevity is the soul of witbrevity is the soul of wit&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb313"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb313-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> phrase <span class="fu">&lt;&gt;</span> phrase</a>
+<a class="sourceLine" id="cb313-2" title="2"><span class="st">&quot;brevity is the soul of witbrevity is the soul of wit&quot;</span></a>
+<a class="sourceLine" id="cb313-3" title="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.append phrase phrase</a>
+<a class="sourceLine" id="cb313-4" title="4"><span class="st">&quot;brevity is the soul of witbrevity is the soul of wit&quot;</span></a>
+<a class="sourceLine" id="cb313-5" title="5"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.concat [phrase,phrase,phrase]</a>
+<a class="sourceLine" id="cb313-6" title="6"><span class="st">&quot;brevity is the soul of witbrevity is the soul of witbrevity is the soul of wit&quot;</span></a></code></pre></div>
 <p>If you want to write a recursive function that pattern matches on a <code>Text</code> like you would on a <code>String</code>, you can use the function <code>T.uncons :: T.Text -&gt; Maybe (Char, T.Text)</code> to split a <code>Text</code> into a head and a tail. Here’s a simple example:</p>
-<div class="sourceCode" id="cb314"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb314-1" data-line-number="1"><span class="ot">countLetter ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb314-2" data-line-number="2">countLetter c t <span class="fu">=</span></a>
-<a class="sourceLine" id="cb314-3" data-line-number="3">  <span class="kw">case</span> T.uncons t <span class="kw">of</span></a>
-<a class="sourceLine" id="cb314-4" data-line-number="4">    <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dv">0</span></a>
-<a class="sourceLine" id="cb314-5" data-line-number="5">    <span class="dt">Just</span> (x,rest) <span class="ot">-&gt;</span> (<span class="kw">if</span> x <span class="fu">==</span> c <span class="kw">then</span> <span class="dv">1</span> <span class="kw">else</span> <span class="dv">0</span>) <span class="fu">+</span> countLetter c rest</a></code></pre></div>
-<div class="sourceCode" id="cb315"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb315-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> countLetter <span class="ch">&#39;t&#39;</span> phrase</a>
-<a class="sourceLine" id="cb315-2" data-line-number="2"><span class="dv">3</span></a></code></pre></div>
+<div class="sourceCode" id="cb314"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb314-1" title="1"><span class="ot">countLetter ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb314-2" title="2">countLetter c t <span class="fu">=</span></a>
+<a class="sourceLine" id="cb314-3" title="3">  <span class="kw">case</span> T.uncons t <span class="kw">of</span></a>
+<a class="sourceLine" id="cb314-4" title="4">    <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="dv">0</span></a>
+<a class="sourceLine" id="cb314-5" title="5">    <span class="dt">Just</span> (x,rest) <span class="ot">-&gt;</span> (<span class="kw">if</span> x <span class="fu">==</span> c <span class="kw">then</span> <span class="dv">1</span> <span class="kw">else</span> <span class="dv">0</span>) <span class="fu">+</span> countLetter c rest</a></code></pre></div>
+<div class="sourceCode" id="cb315"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb315-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> countLetter <span class="ch">&#39;t&#39;</span> phrase</a>
+<a class="sourceLine" id="cb315-2" title="2"><span class="dv">3</span></a></code></pre></div>
 <h4 id="strictness-and-laziness"><span class="header-section-number">14.1.1.1</span> Strictness and Laziness</h4>
 <p>Note that <code>Data.Text</code> implements the strict <code>Text</code> type. You need to use <code>Data.Text.Lazy</code> for the lazy variant. As mentioned earlier, one difference between these two types is that the strict type does not work for infinite strings:</p>
-<div class="sourceCode" id="cb316"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb316-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.head (T.pack (repeat <span class="ch">&#39;x&#39;</span>))</a>
-<a class="sourceLine" id="cb316-2" data-line-number="2"><span class="co">-- never returns</span></a>
-<a class="sourceLine" id="cb316-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text.Lazy</span> <span class="kw">as</span> <span class="dt">TL</span></a>
-<a class="sourceLine" id="cb316-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> TL.head (TL.pack (repeat <span class="ch">&#39;x&#39;</span>))</a>
-<a class="sourceLine" id="cb316-5" data-line-number="5"><span class="ch">&#39;x&#39;</span></a></code></pre></div>
+<div class="sourceCode" id="cb316"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb316-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> T.head (T.pack (<span class="fu">repeat</span> <span class="ch">&#39;x&#39;</span>))</a>
+<a class="sourceLine" id="cb316-2" title="2"><span class="co">-- never returns</span></a>
+<a class="sourceLine" id="cb316-3" title="3"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text.Lazy</span> <span class="kw">as</span> <span class="dt">TL</span></a>
+<a class="sourceLine" id="cb316-4" title="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> TL.head (TL.pack (<span class="fu">repeat</span> <span class="ch">&#39;x&#39;</span>))</a>
+<a class="sourceLine" id="cb316-5" title="5"><span class="ch">&#39;x&#39;</span></a></code></pre></div>
 <p>Another practical problem that sometimes crops is that you can end up with a mismatch between strict and lazy <code>Text</code>s when using libraries. You can usually fix this by using <code>toStrict</code> or <code>fromStrict</code> as needed.</p>
-<div class="sourceCode" id="cb317"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb317-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="kw">let</span> lazyPhrase <span class="fu">=</span> TL.pack <span class="st">&quot;brevity is the soul of wit&quot;</span></a>
-<a class="sourceLine" id="cb317-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t lazyPhrase</a>
-<a class="sourceLine" id="cb317-3" data-line-number="3"><span class="ot">lazyPhrase ::</span> <span class="dt">TL.Text</span></a>
-<a class="sourceLine" id="cb317-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t phrase</a>
-<a class="sourceLine" id="cb317-5" data-line-number="5"><span class="ot">phrase ::</span> <span class="dt">T.Text</span></a>
-<a class="sourceLine" id="cb317-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> lazyPhrase <span class="fu">==</span> phrase</a>
-<a class="sourceLine" id="cb317-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb317-8" data-line-number="8"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb317-9" data-line-number="9">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">TL.Text</span>’</a>
-<a class="sourceLine" id="cb317-10" data-line-number="10">                  with actual <span class="kw">type</span> ‘<span class="dt">T.Text</span>’</a>
-<a class="sourceLine" id="cb317-11" data-line-number="11">      <span class="dt">NB</span><span class="fu">:</span> ‘<span class="dt">T.Text</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.Text.Internal</span>’</a>
-<a class="sourceLine" id="cb317-12" data-line-number="12">          ‘<span class="dt">TL.Text</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.Text.Internal.Lazy</span>’</a>
-<a class="sourceLine" id="cb317-13" data-line-number="13">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">==</span>)’, namely ‘phrase’</a>
-<a class="sourceLine" id="cb317-14" data-line-number="14">      <span class="dt">In</span> the expression<span class="fu">:</span> lazyPhrase <span class="fu">==</span> phrase</a>
-<a class="sourceLine" id="cb317-15" data-line-number="15">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> lazyPhrase <span class="fu">==</span> phrase</a>
-<a class="sourceLine" id="cb317-16" data-line-number="16"></a>
-<a class="sourceLine" id="cb317-17" data-line-number="17"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t TL.toStrict</a>
-<a class="sourceLine" id="cb317-18" data-line-number="18">TL.toStrict<span class="ot"> ::</span> <span class="dt">TL.Text</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
-<a class="sourceLine" id="cb317-19" data-line-number="19"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t TL.fromStrict</a>
-<a class="sourceLine" id="cb317-20" data-line-number="20">TL.fromStrict<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">TL.Text</span></a>
-<a class="sourceLine" id="cb317-21" data-line-number="21"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> TL.toStrict lazyPhrase <span class="fu">==</span> phrase</a>
-<a class="sourceLine" id="cb317-22" data-line-number="22"><span class="dt">True</span></a></code></pre></div>
+<div class="sourceCode" id="cb317"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb317-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="kw">let</span> lazyPhrase <span class="fu">=</span> TL.pack <span class="st">&quot;brevity is the soul of wit&quot;</span></a>
+<a class="sourceLine" id="cb317-2" title="2"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t lazyPhrase</a>
+<a class="sourceLine" id="cb317-3" title="3"><span class="ot">lazyPhrase ::</span> <span class="dt">TL.Text</span></a>
+<a class="sourceLine" id="cb317-4" title="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t phrase</a>
+<a class="sourceLine" id="cb317-5" title="5"><span class="ot">phrase ::</span> <span class="dt">T.Text</span></a>
+<a class="sourceLine" id="cb317-6" title="6"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> lazyPhrase <span class="fu">==</span> phrase</a>
+<a class="sourceLine" id="cb317-7" title="7"></a>
+<a class="sourceLine" id="cb317-8" title="8"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb317-9" title="9">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">TL.Text</span>’</a>
+<a class="sourceLine" id="cb317-10" title="10">                  with actual <span class="kw">type</span> ‘<span class="dt">T.Text</span>’</a>
+<a class="sourceLine" id="cb317-11" title="11">      <span class="dt">NB</span><span class="fu">:</span> ‘<span class="dt">T.Text</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.Text.Internal</span>’</a>
+<a class="sourceLine" id="cb317-12" title="12">          ‘<span class="dt">TL.Text</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.Text.Internal.Lazy</span>’</a>
+<a class="sourceLine" id="cb317-13" title="13">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">==</span>)’, namely ‘phrase’</a>
+<a class="sourceLine" id="cb317-14" title="14">      <span class="dt">In</span> the expression<span class="fu">:</span> lazyPhrase <span class="fu">==</span> phrase</a>
+<a class="sourceLine" id="cb317-15" title="15">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> lazyPhrase <span class="fu">==</span> phrase</a>
+<a class="sourceLine" id="cb317-16" title="16"></a>
+<a class="sourceLine" id="cb317-17" title="17"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t TL.toStrict</a>
+<a class="sourceLine" id="cb317-18" title="18">TL.toStrict<span class="ot"> ::</span> <span class="dt">TL.Text</span> <span class="ot">-&gt;</span> <span class="dt">T.Text</span></a>
+<a class="sourceLine" id="cb317-19" title="19"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> <span class="fu">:</span>t TL.fromStrict</a>
+<a class="sourceLine" id="cb317-20" title="20">TL.fromStrict<span class="ot"> ::</span> <span class="dt">T.Text</span> <span class="ot">-&gt;</span> <span class="dt">TL.Text</span></a>
+<a class="sourceLine" id="cb317-21" title="21"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">TL</span><span class="fu">&gt;</span> TL.toStrict lazyPhrase <span class="fu">==</span> phrase</a>
+<a class="sourceLine" id="cb317-22" title="22"><span class="dt">True</span></a></code></pre></div>
 <h3 id="examples-with-bytestring"><span class="header-section-number">14.1.2</span> Examples with <code>ByteString</code></h3>
 <p>We can walk through pretty much the same GHCi session using <code>ByteString</code> instead of <code>Text</code>. However, note how the <code>ByteString</code> is built up from <code>Word8</code> values and not <code>Char</code> values. A <code>Char</code> can represent an arbitrary unicode codepoint like for a character like <code>'Å'</code>, but a <code>Word8</code> represents a byte: a number from 0 to 255. Unfortunately and somewhat confusingly, <code>ByteString</code> values get printed like <code>String</code>s.</p>
-<div class="sourceCode" id="cb318"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb318-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Word</span></a>
-<a class="sourceLine" id="cb318-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Data.Word</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString</span> <span class="kw">as</span> <span class="dt">B</span></a>
-<a class="sourceLine" id="cb318-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">let</span> binary <span class="fu">=</span> B.pack [<span class="dv">99</span>,<span class="dv">111</span>,<span class="dv">102</span>,<span class="dv">102</span>,<span class="dv">101</span>,<span class="dv">101</span>]</a>
-<a class="sourceLine" id="cb318-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t binary</a>
-<a class="sourceLine" id="cb318-5" data-line-number="5"><span class="ot">binary ::</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb318-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.pack</a>
-<a class="sourceLine" id="cb318-7" data-line-number="7">B.pack<span class="ot"> ::</span> [<span class="dt">Word8</span>] <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb318-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> binary</a>
-<a class="sourceLine" id="cb318-9" data-line-number="9"><span class="st">&quot;coffee&quot;</span></a>
-<a class="sourceLine" id="cb318-10" data-line-number="10"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.length</a>
-<a class="sourceLine" id="cb318-11" data-line-number="11">B.length<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb318-12" data-line-number="12"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.length binary</a>
-<a class="sourceLine" id="cb318-13" data-line-number="13"><span class="dv">6</span></a>
-<a class="sourceLine" id="cb318-14" data-line-number="14"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.head</a>
-<a class="sourceLine" id="cb318-15" data-line-number="15">B.head<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Word8</span></a>
-<a class="sourceLine" id="cb318-16" data-line-number="16"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.head binary</a>
-<a class="sourceLine" id="cb318-17" data-line-number="17"><span class="dv">99</span></a>
-<a class="sourceLine" id="cb318-18" data-line-number="18"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.take <span class="dv">4</span> binary</a>
-<a class="sourceLine" id="cb318-19" data-line-number="19"><span class="st">&quot;coff&quot;</span></a>
-<a class="sourceLine" id="cb318-20" data-line-number="20"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.map</a>
-<a class="sourceLine" id="cb318-21" data-line-number="21">B.map<span class="ot"> ::</span> (<span class="dt">Word8</span> <span class="ot">-&gt;</span> <span class="dt">Word8</span>) <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb318-22" data-line-number="22"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.map (<span class="fu">+</span><span class="dv">1</span>) binary</a>
-<a class="sourceLine" id="cb318-23" data-line-number="23"><span class="st">&quot;dpggff&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb318"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb318-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Word</span></a>
+<a class="sourceLine" id="cb318-2" title="2"><span class="dt">Prelude</span> <span class="dt">Data.Word</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString</span> <span class="kw">as</span> <span class="dt">B</span></a>
+<a class="sourceLine" id="cb318-3" title="3"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">let</span> binary <span class="fu">=</span> B.pack [<span class="dv">99</span>,<span class="dv">111</span>,<span class="dv">102</span>,<span class="dv">102</span>,<span class="dv">101</span>,<span class="dv">101</span>]</a>
+<a class="sourceLine" id="cb318-4" title="4"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t binary</a>
+<a class="sourceLine" id="cb318-5" title="5"><span class="ot">binary ::</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb318-6" title="6"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.pack</a>
+<a class="sourceLine" id="cb318-7" title="7">B.pack<span class="ot"> ::</span> [<span class="dt">Word8</span>] <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb318-8" title="8"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> binary</a>
+<a class="sourceLine" id="cb318-9" title="9"><span class="st">&quot;coffee&quot;</span></a>
+<a class="sourceLine" id="cb318-10" title="10"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.length</a>
+<a class="sourceLine" id="cb318-11" title="11">B.length<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb318-12" title="12"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.length binary</a>
+<a class="sourceLine" id="cb318-13" title="13"><span class="dv">6</span></a>
+<a class="sourceLine" id="cb318-14" title="14"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.head</a>
+<a class="sourceLine" id="cb318-15" title="15">B.head<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Word8</span></a>
+<a class="sourceLine" id="cb318-16" title="16"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.head binary</a>
+<a class="sourceLine" id="cb318-17" title="17"><span class="dv">99</span></a>
+<a class="sourceLine" id="cb318-18" title="18"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.take <span class="dv">4</span> binary</a>
+<a class="sourceLine" id="cb318-19" title="19"><span class="st">&quot;coff&quot;</span></a>
+<a class="sourceLine" id="cb318-20" title="20"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.map</a>
+<a class="sourceLine" id="cb318-21" title="21">B.map<span class="ot"> ::</span> (<span class="dt">Word8</span> <span class="ot">-&gt;</span> <span class="dt">Word8</span>) <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb318-22" title="22"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> B.map (<span class="fu">+</span><span class="dv">1</span>) binary</a>
+<a class="sourceLine" id="cb318-23" title="23"><span class="st">&quot;dpggff&quot;</span></a></code></pre></div>
 <p>The same caveats apply to the differences between strict and lazy <code>ByteString</code> as for <code>Text</code>:</p>
-<div class="sourceCode" id="cb319"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb319-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">B</span> <span class="dt">Data.Char</span><span class="fu">&gt;</span> B.head (B.pack (repeat <span class="dv">99</span>))</a>
-<a class="sourceLine" id="cb319-2" data-line-number="2"><span class="co">-- never returns</span></a>
-<a class="sourceLine" id="cb319-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Lazy</span> <span class="kw">as</span> <span class="dt">BL</span></a>
-<a class="sourceLine" id="cb319-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> BL.head (BL.pack (repeat <span class="dv">99</span>))</a>
-<a class="sourceLine" id="cb319-5" data-line-number="5"><span class="dv">99</span></a>
-<a class="sourceLine" id="cb319-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
-<a class="sourceLine" id="cb319-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb319-8" data-line-number="8"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb319-9" data-line-number="9">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">B.ByteString</span>’</a>
-<a class="sourceLine" id="cb319-10" data-line-number="10">                  with actual <span class="kw">type</span> ‘<span class="dt">BL.ByteString</span>’</a>
-<a class="sourceLine" id="cb319-11" data-line-number="11">      <span class="dt">NB</span><span class="fu">:</span> ‘<span class="dt">BL.ByteString</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.ByteString.Lazy.Internal</span>’</a>
-<a class="sourceLine" id="cb319-12" data-line-number="12">          ‘<span class="dt">B.ByteString</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.ByteString.Internal</span>’</a>
-<a class="sourceLine" id="cb319-13" data-line-number="13">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">==</span>)’, namely ‘BL.pack [<span class="dv">99</span>]’</a>
-<a class="sourceLine" id="cb319-14" data-line-number="14">      <span class="dt">In</span> the expression<span class="fu">:</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
-<a class="sourceLine" id="cb319-15" data-line-number="15">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
-<a class="sourceLine" id="cb319-16" data-line-number="16"></a>
-<a class="sourceLine" id="cb319-17" data-line-number="17"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> <span class="fu">:</span>t BL.toStrict</a>
-<a class="sourceLine" id="cb319-18" data-line-number="18">BL.toStrict<span class="ot"> ::</span> <span class="dt">BL.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb319-19" data-line-number="19"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> <span class="fu">:</span>t BL.fromStrict</a>
-<a class="sourceLine" id="cb319-20" data-line-number="20">BL.fromStrict<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">BL.ByteString</span></a>
-<a class="sourceLine" id="cb319-21" data-line-number="21"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> binary <span class="fu">==</span> BL.toStrict (BL.pack [<span class="dv">99</span>])</a>
-<a class="sourceLine" id="cb319-22" data-line-number="22"><span class="dt">False</span></a></code></pre></div>
+<div class="sourceCode" id="cb319"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb319-1" title="1"><span class="dt">Prelude</span> <span class="dt">B</span> <span class="dt">Data.Char</span><span class="fu">&gt;</span> B.head (B.pack (<span class="fu">repeat</span> <span class="dv">99</span>))</a>
+<a class="sourceLine" id="cb319-2" title="2"><span class="co">-- never returns</span></a>
+<a class="sourceLine" id="cb319-3" title="3"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Lazy</span> <span class="kw">as</span> <span class="dt">BL</span></a>
+<a class="sourceLine" id="cb319-4" title="4"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> BL.head (BL.pack (<span class="fu">repeat</span> <span class="dv">99</span>))</a>
+<a class="sourceLine" id="cb319-5" title="5"><span class="dv">99</span></a>
+<a class="sourceLine" id="cb319-6" title="6"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
+<a class="sourceLine" id="cb319-7" title="7"></a>
+<a class="sourceLine" id="cb319-8" title="8"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb319-9" title="9">    • <span class="dt">Couldn&#39;t</span> match expected <span class="kw">type</span> ‘<span class="dt">B.ByteString</span>’</a>
+<a class="sourceLine" id="cb319-10" title="10">                  with actual <span class="kw">type</span> ‘<span class="dt">BL.ByteString</span>’</a>
+<a class="sourceLine" id="cb319-11" title="11">      <span class="dt">NB</span><span class="fu">:</span> ‘<span class="dt">BL.ByteString</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.ByteString.Lazy.Internal</span>’</a>
+<a class="sourceLine" id="cb319-12" title="12">          ‘<span class="dt">B.ByteString</span>’ is defined <span class="kw">in</span> ‘<span class="dt">Data.ByteString.Internal</span>’</a>
+<a class="sourceLine" id="cb319-13" title="13">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘(<span class="fu">==</span>)’, namely ‘BL.pack [<span class="dv">99</span>]’</a>
+<a class="sourceLine" id="cb319-14" title="14">      <span class="dt">In</span> the expression<span class="fu">:</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
+<a class="sourceLine" id="cb319-15" title="15">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> binary <span class="fu">==</span> BL.pack [<span class="dv">99</span>]</a>
+<a class="sourceLine" id="cb319-16" title="16"></a>
+<a class="sourceLine" id="cb319-17" title="17"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> <span class="fu">:</span>t BL.toStrict</a>
+<a class="sourceLine" id="cb319-18" title="18">BL.toStrict<span class="ot"> ::</span> <span class="dt">BL.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb319-19" title="19"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> <span class="fu">:</span>t BL.fromStrict</a>
+<a class="sourceLine" id="cb319-20" title="20">BL.fromStrict<span class="ot"> ::</span> <span class="dt">B.ByteString</span> <span class="ot">-&gt;</span> <span class="dt">BL.ByteString</span></a>
+<a class="sourceLine" id="cb319-21" title="21"><span class="dt">Prelude</span> <span class="dt">Data.Word</span> <span class="dt">B</span> <span class="dt">BL</span><span class="fu">&gt;</span> binary <span class="fu">==</span> BL.toStrict (BL.pack [<span class="dv">99</span>])</a>
+<a class="sourceLine" id="cb319-22" title="22"><span class="dt">False</span></a></code></pre></div>
 <h3 id="sidenote-encodings"><span class="header-section-number">14.1.3</span> Sidenote: Encodings</h3>
 <p>You might be wondering why on earth do we have both Text and ByteString. The difference is subtle but real. When we operate on <code>Text</code> we operate character by character, regardless of what those characters are and how they are encoded. When we operate on <code>ByteString</code> we operate on bytes, regardless of what those bytes represent.</p>
 <p>Characters, numbers, and data structures are abstractions that help us humans to deal with complex programming tasks. The computer memory is essentially just an enormous sequence of bytes. The machine doesn’t care how we interpret those bytes. The essential difference between <code>Text</code> and <code>ByteString</code> is the way how the bytes are grouped and interpreted.</p>
@@ -3556,35 +3554,35 @@ None of the above
 <p>If we read the same stream of bits using a different encoding, we’ll see other characters. For example the string above would be interpreted as “Ha∫keλ!” using the <a href="https://en.wikipedia.org/wiki/Latin-1">Latin-1 text encoding</a>.</p>
 <p>By the way, when dealing with raw binary data, it’s often convenient to use the hexadecimal number system which uses a single symbol <code>0</code>, <code>1</code>, …, <code>9</code>, <code>A</code>, <code>B</code>, …, <code>F</code> to represent all of the sixteen possible combinations of four bits. We don’t need hexadecimal in this course but you can check out <a href="https://en.wikipedia.org/wiki/Hexadecimal">Wikipedia</a> if you’re interested in learning more about hexadecimal.</p>
 <p>We can explore the same example using code. The function <code>Data.Text.Encoding.encodeUtf8 :: Text -&gt; ByteString</code> encodes the characters in a Text into bytes in a ByteString using UTF-8.</p>
-<div class="sourceCode" id="cb320"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb320-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
-<a class="sourceLine" id="cb320-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString</span> <span class="kw">as</span> <span class="dt">B</span></a>
-<a class="sourceLine" id="cb320-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> T.length (T.pack <span class="st">&quot;haskell&quot;</span>)</a>
-<a class="sourceLine" id="cb320-4" data-line-number="4"><span class="dv">7</span></a>
-<a class="sourceLine" id="cb320-5" data-line-number="5"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> T.length (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>)</a>
-<a class="sourceLine" id="cb320-6" data-line-number="6"><span class="dv">7</span></a>
-<a class="sourceLine" id="cb320-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Text.Encoding</span></a>
-<a class="sourceLine" id="cb320-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> encodeUtf8 (T.pack <span class="st">&quot;haskell&quot;</span>)</a>
-<a class="sourceLine" id="cb320-9" data-line-number="9"><span class="st">&quot;haskell&quot;</span></a>
-<a class="sourceLine" id="cb320-10" data-line-number="10"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> encodeUtf8 (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>)</a>
-<a class="sourceLine" id="cb320-11" data-line-number="11"><span class="st">&quot;Ha\226\136\171ke\206\187!&quot;</span></a>
-<a class="sourceLine" id="cb320-12" data-line-number="12"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> B.length (encodeUtf8 (T.pack <span class="st">&quot;haskell&quot;</span>))</a>
-<a class="sourceLine" id="cb320-13" data-line-number="13"><span class="dv">7</span></a>
-<a class="sourceLine" id="cb320-14" data-line-number="14"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> B.length (encodeUtf8 (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>))</a>
-<a class="sourceLine" id="cb320-15" data-line-number="15"><span class="dv">10</span></a></code></pre></div>
+<div class="sourceCode" id="cb320"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb320-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
+<a class="sourceLine" id="cb320-2" title="2"><span class="dt">Prelude</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString</span> <span class="kw">as</span> <span class="dt">B</span></a>
+<a class="sourceLine" id="cb320-3" title="3"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> T.length (T.pack <span class="st">&quot;haskell&quot;</span>)</a>
+<a class="sourceLine" id="cb320-4" title="4"><span class="dv">7</span></a>
+<a class="sourceLine" id="cb320-5" title="5"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> T.length (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>)</a>
+<a class="sourceLine" id="cb320-6" title="6"><span class="dv">7</span></a>
+<a class="sourceLine" id="cb320-7" title="7"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Text.Encoding</span></a>
+<a class="sourceLine" id="cb320-8" title="8"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> encodeUtf8 (T.pack <span class="st">&quot;haskell&quot;</span>)</a>
+<a class="sourceLine" id="cb320-9" title="9"><span class="st">&quot;haskell&quot;</span></a>
+<a class="sourceLine" id="cb320-10" title="10"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> encodeUtf8 (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>)</a>
+<a class="sourceLine" id="cb320-11" title="11"><span class="st">&quot;Ha\226\136\171ke\206\187!&quot;</span></a>
+<a class="sourceLine" id="cb320-12" title="12"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> B.length (encodeUtf8 (T.pack <span class="st">&quot;haskell&quot;</span>))</a>
+<a class="sourceLine" id="cb320-13" title="13"><span class="dv">7</span></a>
+<a class="sourceLine" id="cb320-14" title="14"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">Data.Text.Encoding</span><span class="fu">&gt;</span> B.length (encodeUtf8 (T.pack <span class="st">&quot;Ha∫keλ!&quot;</span>))</a>
+<a class="sourceLine" id="cb320-15" title="15"><span class="dv">10</span></a></code></pre></div>
 <p>If we are processing <a href="https://en.wikipedia.org/wiki/ASCII">ASCII text</a>, that is, characters that can be represented using single bytes, we can use <code>Text</code> and <code>ByteString</code> interchangeably. There are namespaces <code>Data.ByteString.Char8</code> and <code>Data.ByteString.Lazy.Char8</code> that offer functions that operate on <code>ByteString</code>s using <code>Char</code> values instead of <code>Word8</code>. However, care must be taken to make sure all the characters really are plain ASCII characters, or surprising things will happen.</p>
-<div class="sourceCode" id="cb321"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb321-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Char8</span> <span class="kw">as</span> <span class="dt">B8</span></a>
-<a class="sourceLine" id="cb321-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> B8.pack <span class="st">&quot;abc&quot;</span></a>
-<a class="sourceLine" id="cb321-3" data-line-number="3"><span class="st">&quot;abc&quot;</span></a>
-<a class="sourceLine" id="cb321-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">:</span>t B8.pack</a>
-<a class="sourceLine" id="cb321-5" data-line-number="5">B8.pack<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb321-6" data-line-number="6"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.pack</a>
-<a class="sourceLine" id="cb321-7" data-line-number="7">B.pack<span class="ot"> ::</span> [<span class="dt">Word8</span>] <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
-<a class="sourceLine" id="cb321-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> B8.cons <span class="ch">&#39;a&#39;</span> (B8.pack <span class="st">&quot;bc&quot;</span>)</a>
-<a class="sourceLine" id="cb321-9" data-line-number="9"><span class="st">&quot;abc&quot;</span></a>
-<a class="sourceLine" id="cb321-10" data-line-number="10"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> putStrLn (B8.unpack (B8.pack <span class="st">&quot;€λ훈&quot;</span>))  <span class="co">-- non-ASCII characters get truncated</span></a>
-<a class="sourceLine" id="cb321-11" data-line-number="11">¬»È</a>
-<a class="sourceLine" id="cb321-12" data-line-number="12"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> putStrLn (T.unpack (T.pack <span class="st">&quot;€λ훈&quot;</span>))</a>
-<a class="sourceLine" id="cb321-13" data-line-number="13">€λ훈</a></code></pre></div>
+<div class="sourceCode" id="cb321"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb321-1" title="1"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Char8</span> <span class="kw">as</span> <span class="dt">B8</span></a>
+<a class="sourceLine" id="cb321-2" title="2"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> B8.pack <span class="st">&quot;abc&quot;</span></a>
+<a class="sourceLine" id="cb321-3" title="3"><span class="st">&quot;abc&quot;</span></a>
+<a class="sourceLine" id="cb321-4" title="4"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">:</span>t B8.pack</a>
+<a class="sourceLine" id="cb321-5" title="5">B8.pack<span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb321-6" title="6"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">:</span>t B.pack</a>
+<a class="sourceLine" id="cb321-7" title="7">B.pack<span class="ot"> ::</span> [<span class="dt">Word8</span>] <span class="ot">-&gt;</span> <span class="dt">B.ByteString</span></a>
+<a class="sourceLine" id="cb321-8" title="8"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> B8.cons <span class="ch">&#39;a&#39;</span> (B8.pack <span class="st">&quot;bc&quot;</span>)</a>
+<a class="sourceLine" id="cb321-9" title="9"><span class="st">&quot;abc&quot;</span></a>
+<a class="sourceLine" id="cb321-10" title="10"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">putStrLn</span> (B8.unpack (B8.pack <span class="st">&quot;€λ훈&quot;</span>))  <span class="co">-- non-ASCII characters get truncated</span></a>
+<a class="sourceLine" id="cb321-11" title="11">¬»È</a>
+<a class="sourceLine" id="cb321-12" title="12"><span class="dt">Prelude</span> <span class="dt">T</span> <span class="dt">B</span> <span class="dt">B8</span><span class="fu">&gt;</span> <span class="fu">putStrLn</span> (T.unpack (T.pack <span class="st">&quot;€λ훈&quot;</span>))</a>
+<a class="sourceLine" id="cb321-13" title="13">€λ훈</a></code></pre></div>
 <h2 id="monads-recap"><span class="header-section-number">14.2</span> Monads: Recap</h2>
 <p>The next libraries we’ll look at work inside the IO monad. Here’s a short recap of what we learned about monads in the last lecture.</p>
 <ul>
@@ -3598,45 +3596,45 @@ None of the above
 <li>Unlike in other languages, <code>return</code> is not a keyword and does not cause an operation to stop executing. Instead, <code>return x</code> <em>is the operation that always produces x and does nothing else</em>.</li>
 <li>This is what <code>do</code>-notation looks like:</li>
 </ul>
-<div class="sourceCode" id="cb322"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb322-1" data-line-number="1">foo y <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb322-2" data-line-number="2">  operation1         <span class="co">-- run an operation</span></a>
-<a class="sourceLine" id="cb322-3" data-line-number="3">  val <span class="ot">&lt;-</span> operation2  <span class="co">-- run an operation and keep the produced value</span></a>
-<a class="sourceLine" id="cb322-4" data-line-number="4">  operation3 val y   <span class="co">-- run an operation with parameters</span></a>
-<a class="sourceLine" id="cb322-5" data-line-number="5">  mapM_ (\x <span class="ot">-&gt;</span> operation4 val x) things  <span class="co">-- use a generic monad operation and a lambda</span></a>
-<a class="sourceLine" id="cb322-6" data-line-number="6">  operation5 val     <span class="co">-- the final line of the do decides which value the whole block produces</span></a></code></pre></div>
+<div class="sourceCode" id="cb322"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb322-1" title="1">foo y <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb322-2" title="2">  operation1         <span class="co">-- run an operation</span></a>
+<a class="sourceLine" id="cb322-3" title="3">  val <span class="ot">&lt;-</span> operation2  <span class="co">-- run an operation and keep the produced value</span></a>
+<a class="sourceLine" id="cb322-4" title="4">  operation3 val y   <span class="co">-- run an operation with parameters</span></a>
+<a class="sourceLine" id="cb322-5" title="5">  <span class="fu">mapM_</span> (\x <span class="ot">-&gt;</span> operation4 val x) things  <span class="co">-- use a generic monad operation and a lambda</span></a>
+<a class="sourceLine" id="cb322-6" title="6">  operation5 val     <span class="co">-- the final line of the do decides which value the whole block produces</span></a></code></pre></div>
 <!-- TODO more? -->
 <h2 id="writing-a-http-server-wai-and-warp"><span class="header-section-number">14.3</span> Writing a HTTP Server: WAI and Warp</h2>
 <p>Sometimes it feels like everything in the world happens over <a href="https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol">HTTP</a> and <a href="https://en.wikipedia.org/wiki/Web_API">Web Apis</a>. Your web browser, your smartphone apps, <a href="https://developer.nordeaopenbanking.com/">your bank</a>, <a href="https://tools.ietf.org/html/rfc2324">your coffee pot</a>, <a href="https://support.ring.com/hc/en-us/articles/205385394-The-Protocols-and-Ports-Used-by-Ring-Devices">and even your doorbell</a>, all talk to servers using the HTTP protocol.</p>
 <p>Let’s look at how we can set up a simple HTTP server in Haskell. The standard low level components for this are called <a href="https://hackage.haskell.org/package/wai-3.2.3/docs/Network-Wai.html">WAI</a> and <a href="http://hackage.haskell.org/package/warp-3.3.14">Warp</a>. WAI, the Web Application Interface gives us a way to define how HTTP requests are handled. Warp is a simple HTTP server that runs the logic we have defined using WAI. That probably sounds a bit abstract right now, but a simple example will help.</p>
 <p>The file <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/HelloServer.hs"><code>exercises/Examples/HelloServer.hs</code></a> implements a HTTP server that always responds with “Hello World!”. You can try it out by going to the <code>exercises/Examples</code> directory and running it with <code>stack runhaskell HelloServer.hs</code>. After that you can visit <a href="http://localhost:3421" class="uri">http://localhost:3421</a> in your browser to see the response from the server.</p>
-<div class="sourceCode" id="cb323"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb323-1" data-line-number="1"><span class="kw">module</span> <span class="dt">Examples.HelloServer</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb323-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb323-3" data-line-number="3"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Lazy.Char8</span> <span class="kw">as</span> <span class="dt">BL</span></a>
-<a class="sourceLine" id="cb323-4" data-line-number="4"><span class="kw">import</span> <span class="dt">Network.HTTP.Types.Status</span> (status200)</a>
-<a class="sourceLine" id="cb323-5" data-line-number="5"><span class="kw">import</span> <span class="dt">Network.Wai</span> (<span class="dt">Application</span>, responseLBS)</a>
-<a class="sourceLine" id="cb323-6" data-line-number="6"><span class="kw">import</span> <span class="dt">Network.Wai.Handler.Warp</span> (run)</a>
-<a class="sourceLine" id="cb323-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb323-8" data-line-number="8"><span class="ot">port ::</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb323-9" data-line-number="9">port <span class="fu">=</span> <span class="dv">3421</span></a>
-<a class="sourceLine" id="cb323-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb323-11" data-line-number="11"><span class="ot">main ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb323-12" data-line-number="12">main <span class="fu">=</span> run port application</a>
-<a class="sourceLine" id="cb323-13" data-line-number="13"></a>
-<a class="sourceLine" id="cb323-14" data-line-number="14"><span class="co">-- type Application = Request -&gt; (Response -&gt; IO ResponseReceived) -&gt; IO ResponseReceived</span></a>
-<a class="sourceLine" id="cb323-15" data-line-number="15"><span class="ot">application ::</span> <span class="dt">Application</span></a>
-<a class="sourceLine" id="cb323-16" data-line-number="16">application request respond <span class="fu">=</span></a>
-<a class="sourceLine" id="cb323-17" data-line-number="17">  respond (responseLBS status200 [] (BL.pack <span class="st">&quot;Hello World!&quot;</span>))</a></code></pre></div>
+<div class="sourceCode" id="cb323"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb323-1" title="1"><span class="kw">module</span> <span class="dt">Examples.HelloServer</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb323-2" title="2"></a>
+<a class="sourceLine" id="cb323-3" title="3"><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.ByteString.Lazy.Char8</span> <span class="kw">as</span> <span class="dt">BL</span></a>
+<a class="sourceLine" id="cb323-4" title="4"><span class="kw">import</span> <span class="dt">Network.HTTP.Types.Status</span> (status200)</a>
+<a class="sourceLine" id="cb323-5" title="5"><span class="kw">import</span> <span class="dt">Network.Wai</span> (<span class="dt">Application</span>, responseLBS)</a>
+<a class="sourceLine" id="cb323-6" title="6"><span class="kw">import</span> <span class="dt">Network.Wai.Handler.Warp</span> (run)</a>
+<a class="sourceLine" id="cb323-7" title="7"></a>
+<a class="sourceLine" id="cb323-8" title="8"><span class="ot">port ::</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb323-9" title="9">port <span class="fu">=</span> <span class="dv">3421</span></a>
+<a class="sourceLine" id="cb323-10" title="10"></a>
+<a class="sourceLine" id="cb323-11" title="11"><span class="ot">main ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb323-12" title="12">main <span class="fu">=</span> run port application</a>
+<a class="sourceLine" id="cb323-13" title="13"></a>
+<a class="sourceLine" id="cb323-14" title="14"><span class="co">-- type Application = Request -&gt; (Response -&gt; IO ResponseReceived) -&gt; IO ResponseReceived</span></a>
+<a class="sourceLine" id="cb323-15" title="15"><span class="ot">application ::</span> <span class="dt">Application</span></a>
+<a class="sourceLine" id="cb323-16" title="16">application request respond <span class="fu">=</span></a>
+<a class="sourceLine" id="cb323-17" title="17">  respond (responseLBS status200 [] (BL.pack <span class="st">&quot;Hello World!&quot;</span>))</a></code></pre></div>
 <p>Let’s look at the types in this example. There’s a lot going on here. First off, <code>Application</code> is a <em>type alias</em> for a thing that implements the logic of a web server. The <a href="http://hackage.haskell.org/package/warp-3.3.14/docs/Network-Wai-Handler-Warp.html#v:run"><code>run</code> function from Warp</a> can run <code>Application</code>s:</p>
-<div class="sourceCode" id="cb324"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb324-1" data-line-number="1"><span class="ot">run ::</span> <span class="dt">Port</span> <span class="ot">-&gt;</span> <span class="dt">Application</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb324-2" data-line-number="2"><span class="kw">type</span> <span class="dt">Application</span> <span class="fu">=</span> <span class="dt">Request</span> <span class="ot">-&gt;</span> (<span class="dt">Response</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">ResponseReceived</span>) <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">ResponseReceived</span></a></code></pre></div>
+<div class="sourceCode" id="cb324"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb324-1" title="1"><span class="ot">run ::</span> <span class="dt">Port</span> <span class="ot">-&gt;</span> <span class="dt">Application</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb324-2" title="2"><span class="kw">type</span> <span class="dt">Application</span> <span class="fu">=</span> <span class="dt">Request</span> <span class="ot">-&gt;</span> (<span class="dt">Response</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">ResponseReceived</span>) <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">ResponseReceived</span></a></code></pre></div>
 <p>We’ll talk about what <code>Request</code> and <code>Response</code> are soon, but from this type we can see that an <code>Application</code> is an IO operation that takes as arguments a request of type <code>Request</code>, and an IO operation <code>respond :: Response -&gt; IO ResponseReceived</code>. Arguments like <code>respond</code> are called <em>callbacks</em> in many contexts. They allow us to call back to the library who called the application. The <code>Application</code> operation has to produce the same special <code>ResponseReceived</code> type that <code>respond</code>. You can think of this type as a token proving that <code>respond</code> was called by the <code>Application</code>.</p>
 <p>That might sound intimidating: but looking at the code things are relatively simple: our <code>server</code> is an <code>Application</code> and takes two parameters: <code>request</code> and <code>respond</code>.</p>
 <p>WAI uses lots of types like <code>Port</code>, <code>Request</code>, <code>Response</code>, <code>Status</code> to represent HTTP concepts. It’s useful to look these up in the documentation when you bump into them. For example <a href="http://hackage.haskell.org/package/warp-3.3.14/docs/Network-Wai-Handler-Warp.html#t:Port"><code>Port</code> is just an alias for <code>Int</code></a>. As another example, we can see the <a href="https://hackage.haskell.org/package/wai-3.2.2.1/docs/Network-Wai.html#v:responseLBS"><code>responseLBS</code> function</a> has the type</p>
-<div class="sourceCode" id="cb325"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb325-1" data-line-number="1"><span class="ot">responseLBS ::</span> <span class="dt">Status</span> <span class="ot">-&gt;</span> <span class="dt">ResponseHeaders</span> <span class="ot">-&gt;</span> <span class="dt">ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Response</span></a></code></pre></div>
+<div class="sourceCode" id="cb325"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb325-1" title="1"><span class="ot">responseLBS ::</span> <span class="dt">Status</span> <span class="ot">-&gt;</span> <span class="dt">ResponseHeaders</span> <span class="ot">-&gt;</span> <span class="dt">ByteString</span> <span class="ot">-&gt;</span> <span class="dt">Response</span></a></code></pre></div>
 <p>where <a href="https://hackage.haskell.org/package/http-types-0.12.3/docs/Network-HTTP-Types-Status.html#t:Status"><code>Status</code> is defined in <code>Network.HTTP.Types.Status</code></a>, <a href="https://hackage.haskell.org/package/http-types-0.12.3/docs/Network-HTTP-Types-Header.html#t:ResponseHeaders"><code>ResponseHeaders</code> is a type alias for <code>[Header]</code> from <code>Network.HTTP.Types.Header</code></a>, <code>ByteString</code> is a lazy <code>ByteString</code>, and the result type <a href="https://hackage.haskell.org/package/wai-3.2.3/docs/Network-Wai.html#t:Response"><code>Response</code> is defined by <code>Network.WAI</code></a>.</p>
 <p>Finally, note that we take a shortcut and use the function <code>Data.ByteString.Lazy.Char8.pack</code> to convert a <code>String</code> into a <code>ByteString</code>. This only works for ASCII text.</p>
 <p>A web server that always responds with the same text isn’t that interesting. Let’s look at how we can give different responses to different requests next. There are many parts in a HTTP request, but for this lecture we’re going to focus on the <em>path</em>. In a URL like <code>http://example.com/abcd/ef/file</code>, the <code>/abcd/ef/file</code> part is the path. WAI has the function</p>
-<div class="sourceCode" id="cb326"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb326-1" data-line-number="1"><span class="ot">pathInfo ::</span> <span class="dt">Request</span> <span class="ot">-&gt;</span> [<span class="dt">Text</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb326"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb326-1" title="1"><span class="ot">pathInfo ::</span> <span class="dt">Request</span> <span class="ot">-&gt;</span> [<span class="dt">Text</span>]</a></code></pre></div>
 <p>This gives us the path of the requested URL, split at the <code>/</code> characters.</p>
 <p>The file <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/PathServer.hs"><code>exercises/Examples/PathServer.hs</code></a> implements a web server that has three different pages:</p>
 <ul>
@@ -3652,67 +3650,67 @@ None of the above
 <p>In case you’re not familiar with SQL, don’t worry, you won’t need to write any queries of your own in the exercises. If you’d like to learn a bit of SQL now, there are lots of tutorials on the web. See <a href="https://www.w3schools.com/sql/">W3Schools</a>, <a href="https://sqlzoo.net/">SQL Zoo</a> or <a href="https://www.codecademy.com/learn/learn-sql">Codecademy</a>.</p>
 <p>There are many libraries for Haskell for using SQLite, but we’ll look at one called <a href="https://hackage.haskell.org/package/sqlite-simple-0.4.18.0">sqlite-simple</a> here. Let’s explore the library in GHCi for a bit.</p>
 <p>All the functions live inside <code>Database.SQLite.Simple</code>. You can open a database by giving a filename to <code>open</code>, which is an IO operation that produces a <code>Connection</code>.</p>
-<div class="sourceCode" id="cb327"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb327-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Database.SQLite.Simple</span></a>
-<a class="sourceLine" id="cb327-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>t open</a>
-<a class="sourceLine" id="cb327-3" data-line-number="3"><span class="ot">open ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Connection</span></a>
-<a class="sourceLine" id="cb327-4" data-line-number="4"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> db <span class="ot">&lt;-</span> open <span class="st">&quot;example.sqlite&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb327"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb327-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Database.SQLite.Simple</span></a>
+<a class="sourceLine" id="cb327-2" title="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>t open</a>
+<a class="sourceLine" id="cb327-3" title="3"><span class="ot">open ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Connection</span></a>
+<a class="sourceLine" id="cb327-4" title="4"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> db <span class="ot">&lt;-</span> open <span class="st">&quot;example.sqlite&quot;</span></a></code></pre></div>
 <p>To run an SQL query you can use IO operation <code>query_</code>, which takes a <code>Connection</code> and a <code>Query</code>, and produces a list of results. The <code>Query</code> type is just a simple <code>newtype</code> around <code>Text</code>. The result type of <code>query_</code>is polymorphic: you can read any type that satisfies the <code>FromRow</code> type class from the database. If this feels confusing, compare it to the type of <code>read</code>: <code>Read a =&gt; String -&gt; a</code>. The <code>FromRow</code> class is like <code>Read</code> for this database: it represents types that can be read out of the database. Anyway, let’s read the number <code>1</code> from the database:</p>
-<div class="sourceCode" id="cb328"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb328-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>t query_</a>
-<a class="sourceLine" id="cb328-2" data-line-number="2"><span class="ot">query_ ::</span> <span class="dt">FromRow</span> r <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [r]</a>
-<a class="sourceLine" id="cb328-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Query</span></a>
-<a class="sourceLine" id="cb328-4" data-line-number="4"><span class="kw">newtype</span> <span class="dt">Query</span> <span class="fu">=</span> <span class="dt">Query</span> {<span class="ot">fromQuery ::</span> <span class="dt">Data.Text.Internal.Text</span>}</a>
-<a class="sourceLine" id="cb328-5" data-line-number="5">    <span class="co">-- Defined in ‘Database.SQLite.Simple.Types’</span></a>
-<a class="sourceLine" id="cb328-6" data-line-number="6">    <span class="co">-- ... rest of output omitted</span></a>
-<a class="sourceLine" id="cb328-7" data-line-number="7"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
-<a class="sourceLine" id="cb328-8" data-line-number="8"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> q <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT 1;&quot;</span>)</a>
-<a class="sourceLine" id="cb328-9" data-line-number="9"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res <span class="ot">&lt;-</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [[<span class="dt">Int</span>]]</a>
-<a class="sourceLine" id="cb328-10" data-line-number="10"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res</a>
-<a class="sourceLine" id="cb328-11" data-line-number="11">[[<span class="dv">1</span>]]</a></code></pre></div>
+<div class="sourceCode" id="cb328"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb328-1" title="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>t query_</a>
+<a class="sourceLine" id="cb328-2" title="2"><span class="ot">query_ ::</span> <span class="dt">FromRow</span> r <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> [r]</a>
+<a class="sourceLine" id="cb328-3" title="3"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="fu">:</span>info <span class="dt">Query</span></a>
+<a class="sourceLine" id="cb328-4" title="4"><span class="kw">newtype</span> <span class="dt">Query</span> <span class="fu">=</span> <span class="dt">Query</span> {<span class="ot">fromQuery ::</span> <span class="dt">Data.Text.Internal.Text</span>}</a>
+<a class="sourceLine" id="cb328-5" title="5">    <span class="co">-- Defined in ‘Database.SQLite.Simple.Types’</span></a>
+<a class="sourceLine" id="cb328-6" title="6">    <span class="co">-- ... rest of output omitted</span></a>
+<a class="sourceLine" id="cb328-7" title="7"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Text</span> <span class="kw">as</span> <span class="dt">T</span></a>
+<a class="sourceLine" id="cb328-8" title="8"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> q <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT 1;&quot;</span>)</a>
+<a class="sourceLine" id="cb328-9" title="9"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res <span class="ot">&lt;-</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [[<span class="dt">Int</span>]]</a>
+<a class="sourceLine" id="cb328-10" title="10"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res</a>
+<a class="sourceLine" id="cb328-11" title="11">[[<span class="dv">1</span>]]</a></code></pre></div>
 <p>By the way, all of these initial examples use simple <code>SELECT x, y, z;</code> queries that just return constant data. We’ll worry about actual tables in the database later.</p>
 <p>Without the type signature, we get an error from GHCi, which can’t decide which type we want to read out from the database:</p>
-<div class="sourceCode" id="cb329"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb329-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res <span class="ot">&lt;-</span> query_ db q</a>
-<a class="sourceLine" id="cb329-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb329-3" data-line-number="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">17</span><span class="fu">:</span><span class="dv">8</span><span class="fu">:</span> error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb329-4" data-line-number="4">    • <span class="dt">Ambiguous</span> <span class="kw">type</span> variable ‘r0’ arising from a use <span class="kw">of</span> ‘query_’</a>
-<a class="sourceLine" id="cb329-5" data-line-number="5">      prevents the constraint ‘(<span class="dt">FromRow</span> r0)’ from being solved<span class="fu">.</span></a>
-<a class="sourceLine" id="cb329-6" data-line-number="6">      <span class="dt">Probable</span> fix<span class="fu">:</span> use a <span class="kw">type</span> annotation to specify what ‘r0’ should be<span class="fu">.</span></a>
-<a class="sourceLine" id="cb329-7" data-line-number="7">      <span class="co">-- rest of error omitted</span></a></code></pre></div>
+<div class="sourceCode" id="cb329"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb329-1" title="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> res <span class="ot">&lt;-</span> query_ db q</a>
+<a class="sourceLine" id="cb329-2" title="2"></a>
+<a class="sourceLine" id="cb329-3" title="3"><span class="fu">&lt;</span>interactive<span class="fu">&gt;:</span><span class="dv">17</span><span class="fu">:</span><span class="dv">8</span><span class="fu">:</span> <span class="fu">error:</span></a>
+<a class="sourceLine" id="cb329-4" title="4">    • <span class="dt">Ambiguous</span> <span class="kw">type</span> variable ‘r0’ arising from a use <span class="kw">of</span> ‘query_’</a>
+<a class="sourceLine" id="cb329-5" title="5">      prevents the constraint ‘(<span class="dt">FromRow</span> r0)’ from being solved<span class="fu">.</span></a>
+<a class="sourceLine" id="cb329-6" title="6">      <span class="dt">Probable</span> fix<span class="fu">:</span> use a <span class="kw">type</span> annotation to specify what ‘r0’ should be<span class="fu">.</span></a>
+<a class="sourceLine" id="cb329-7" title="7">      <span class="co">-- rest of error omitted</span></a></code></pre></div>
 <p>Before we go on, let’s have a closer look at <code>FromRow</code>. If you’ve bumped into SQL before, you know that an SQL query returns a number of <em>rows</em>, and each row consists of a number of <em>values</em> (also called <em>columns</em>). To be able to interpret the result of an SQL query into Haskell data, we need a way to interpret these values and rows. Thus sqlite-simple defines two classes, <code>FromField</code> and <code>FromRow</code>, and a bunch of instances like the following. (You can find these instances from <a href="https://hackage.haskell.org/package/sqlite-simple-0.4.18.0/docs/Database-SQLite-Simple.html#t:FromRow">the docs</a> or by asking GHCi with <code>:info FromRow</code> etc.)</p>
-<div class="sourceCode" id="cb330"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb330-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb330-2" data-line-number="2"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb330-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb330-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Text</span></a>
-<a class="sourceLine" id="cb330-5" data-line-number="5"><span class="kw">instance</span> <span class="dt">FromField</span> a <span class="ot">=&gt;</span> <span class="dt">FromRow</span> [a]</a>
-<a class="sourceLine" id="cb330-6" data-line-number="6"><span class="kw">instance</span> (<span class="dt">FromField</span> a, <span class="dt">FromField</span> b) <span class="ot">=&gt;</span> <span class="dt">FromRow</span> (a,b)</a>
-<a class="sourceLine" id="cb330-7" data-line-number="7"><span class="kw">instance</span> (<span class="dt">FromField</span> a, <span class="dt">FromField</span> b, <span class="dt">FromField</span> c) <span class="ot">=&gt;</span> <span class="dt">FromRow</span> (a,b,c)</a></code></pre></div>
+<div class="sourceCode" id="cb330"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb330-1" title="1"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb330-2" title="2"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb330-3" title="3"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb330-4" title="4"><span class="kw">instance</span> <span class="dt">FromField</span> <span class="dt">Text</span></a>
+<a class="sourceLine" id="cb330-5" title="5"><span class="kw">instance</span> <span class="dt">FromField</span> a <span class="ot">=&gt;</span> <span class="dt">FromRow</span> [a]</a>
+<a class="sourceLine" id="cb330-6" title="6"><span class="kw">instance</span> (<span class="dt">FromField</span> a, <span class="dt">FromField</span> b) <span class="ot">=&gt;</span> <span class="dt">FromRow</span> (a,b)</a>
+<a class="sourceLine" id="cb330-7" title="7"><span class="kw">instance</span> (<span class="dt">FromField</span> a, <span class="dt">FromField</span> b, <span class="dt">FromField</span> c) <span class="ot">=&gt;</span> <span class="dt">FromRow</span> (a,b,c)</a></code></pre></div>
 <p>In essence, basic Haskell datatypes fulfill the <code>FromField</code> class, and various Haskell collections fulfill the <code>FromRow</code> class. Our earlier example was using the <code>FromRow [a]</code> and <code>FromField Int</code> instances to get a <code>[[Int]]</code> out of <code>query_</code>. Here’s a simple query that uses some other datatypes:</p>
-<div class="sourceCode" id="cb331"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb331-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> q <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT 1, true, &#39;string&#39;;&quot;</span>)</a>
-<a class="sourceLine" id="cb331-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Bool</span>,<span class="dt">String</span>)]</a>
-<a class="sourceLine" id="cb331-3" data-line-number="3">[(<span class="dv">1</span>,<span class="dt">True</span>,<span class="st">&quot;string&quot;</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb331"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb331-1" title="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> q <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT 1, true, &#39;string&#39;;&quot;</span>)</a>
+<a class="sourceLine" id="cb331-2" title="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Bool</span>,<span class="dt">String</span>)]</a>
+<a class="sourceLine" id="cb331-3" title="3">[(<span class="dv">1</span>,<span class="dt">True</span>,<span class="st">&quot;string&quot;</span>)]</a></code></pre></div>
 <p>What happens if the SQL and Haskell types don’t match? Well, you get a runtime error, just like if you try to invoke <code>read &quot;True&quot; :: Int</code>.</p>
-<div class="sourceCode" id="cb332"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb332-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
-<a class="sourceLine" id="cb332-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> <span class="dt">ConversionFailed</span> {errSQLType <span class="fu">=</span> <span class="st">&quot;TEXT&quot;</span>, errHaskellType <span class="fu">=</span> <span class="st">&quot;Int&quot;</span>, errMessage <span class="fu">=</span> <span class="st">&quot;need an int&quot;</span>}</a></code></pre></div>
+<div class="sourceCode" id="cb332"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb332-1" title="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query_ db<span class="ot"> q ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Int</span>,<span class="dt">Int</span>)]</a>
+<a class="sourceLine" id="cb332-2" title="2"><span class="fu">***</span> <span class="dt">Exception</span><span class="fu">:</span> <span class="dt">ConversionFailed</span> {errSQLType <span class="fu">=</span> <span class="st">&quot;TEXT&quot;</span>, errHaskellType <span class="fu">=</span> <span class="st">&quot;Int&quot;</span>, errMessage <span class="fu">=</span> <span class="st">&quot;need an int&quot;</span>}</a></code></pre></div>
 <p>To mirror the <code>FromRow</code> and <code>FromField</code> classes, sqlite-simple also defines the <code>ToRow</code> and <code>ToField</code> classes for writing into the database. Here’s the type of the <code>query</code> function, which allows us to use <em>parameterized queries</em>.</p>
-<div class="sourceCode" id="cb333"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb333-1" data-line-number="1"><span class="ot">query ::</span> (<span class="dt">ToRow</span> q, <span class="dt">FromRow</span> r) <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> q <span class="ot">-&gt;</span> <span class="dt">IO</span> [r]</a></code></pre></div>
+<div class="sourceCode" id="cb333"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb333-1" title="1"><span class="ot">query ::</span> (<span class="dt">ToRow</span> q, <span class="dt">FromRow</span> r) <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> q <span class="ot">-&gt;</span> <span class="dt">IO</span> [r]</a></code></pre></div>
 <p>And here are some instances for <code>ToRow</code> and <code>ToField</code>:</p>
-<div class="sourceCode" id="cb334"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb334-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb334-2" data-line-number="2"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb334-3" data-line-number="3"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb334-4" data-line-number="4"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Text</span></a>
-<a class="sourceLine" id="cb334-5" data-line-number="5"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb334-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb334-7" data-line-number="7"><span class="kw">instance</span> <span class="dt">ToField</span> a <span class="ot">=&gt;</span> <span class="dt">ToRow</span> [a]</a>
-<a class="sourceLine" id="cb334-8" data-line-number="8"><span class="kw">instance</span> (<span class="dt">ToField</span> a, <span class="dt">ToField</span> b) <span class="ot">=&gt;</span> <span class="dt">ToRow</span> (a, b)</a>
-<a class="sourceLine" id="cb334-9" data-line-number="9"><span class="kw">instance</span> (<span class="dt">ToField</span> a, <span class="dt">ToField</span> b, <span class="dt">ToField</span> c) <span class="ot">=&gt;</span> <span class="dt">ToRow</span> (a, b, c)</a></code></pre></div>
+<div class="sourceCode" id="cb334"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb334-1" title="1"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb334-2" title="2"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb334-3" title="3"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb334-4" title="4"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Text</span></a>
+<a class="sourceLine" id="cb334-5" title="5"><span class="kw">instance</span> <span class="dt">ToField</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb334-6" title="6"></a>
+<a class="sourceLine" id="cb334-7" title="7"><span class="kw">instance</span> <span class="dt">ToField</span> a <span class="ot">=&gt;</span> <span class="dt">ToRow</span> [a]</a>
+<a class="sourceLine" id="cb334-8" title="8"><span class="kw">instance</span> (<span class="dt">ToField</span> a, <span class="dt">ToField</span> b) <span class="ot">=&gt;</span> <span class="dt">ToRow</span> (a, b)</a>
+<a class="sourceLine" id="cb334-9" title="9"><span class="kw">instance</span> (<span class="dt">ToField</span> a, <span class="dt">ToField</span> b, <span class="dt">ToField</span> c) <span class="ot">=&gt;</span> <span class="dt">ToRow</span> (a, b, c)</a></code></pre></div>
 <!-- instance ToField a => ToField (Maybe a)  -- TODO talk about sql null -->
 <p>Parameterized queries use a <code>?</code> character to denote slots where parameters can be passed in. Here’s a simple example:</p>
-<div class="sourceCode" id="cb335"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb335-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> input <span class="fu">=</span> (<span class="dv">1</span>,<span class="st">&quot;hello&quot;</span>)<span class="ot"> ::</span> (<span class="dt">Int</span>,<span class="dt">String</span>)</a>
-<a class="sourceLine" id="cb335-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> parameterized <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT ?+1, true, ?;&quot;</span>)</a>
-<a class="sourceLine" id="cb335-3" data-line-number="3"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query db parameterized<span class="ot"> input ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Bool</span>,<span class="dt">String</span>)]</a>
-<a class="sourceLine" id="cb335-4" data-line-number="4">[(<span class="dv">2</span>,<span class="dt">True</span>,<span class="st">&quot;hello&quot;</span>)]</a></code></pre></div>
+<div class="sourceCode" id="cb335"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb335-1" title="1"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> input <span class="fu">=</span> (<span class="dv">1</span>,<span class="st">&quot;hello&quot;</span>)<span class="ot"> ::</span> (<span class="dt">Int</span>,<span class="dt">String</span>)</a>
+<a class="sourceLine" id="cb335-2" title="2"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> <span class="kw">let</span> parameterized <span class="fu">=</span> <span class="dt">Query</span> (T.pack <span class="st">&quot;SELECT ?+1, true, ?;&quot;</span>)</a>
+<a class="sourceLine" id="cb335-3" title="3"><span class="dt">Prelude</span> <span class="dt">Database.SQLite.Simple</span> <span class="dt">T</span><span class="fu">&gt;</span> query db parameterized<span class="ot"> input ::</span> <span class="dt">IO</span> [(<span class="dt">Int</span>,<span class="dt">Bool</span>,<span class="dt">String</span>)]</a>
+<a class="sourceLine" id="cb335-4" title="4">[(<span class="dv">2</span>,<span class="dt">True</span>,<span class="st">&quot;hello&quot;</span>)]</a></code></pre></div>
 <p>That’s pretty much all you need to know about sqlite-simple: <code>open</code>, <code>query_</code>, <code>query</code>, <code>FromRow</code>, <code>ToRow</code>. Oh right, one more thing. There are the functions <code>execute</code> and <code>execute_</code> if you don’t need the result of the query. They’re useful for inserting things into the database, for example.</p>
-<div class="sourceCode" id="cb336"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb336-1" data-line-number="1"><span class="ot">execute_ ::</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb336-2" data-line-number="2"><span class="ot">execute ::</span> <span class="dt">ToRow</span> q <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> q <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
+<div class="sourceCode" id="cb336"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb336-1" title="1"><span class="ot">execute_ ::</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb336-2" title="2"><span class="ot">execute ::</span> <span class="dt">ToRow</span> q <span class="ot">=&gt;</span> <span class="dt">Connection</span> <span class="ot">-&gt;</span> <span class="dt">Query</span> <span class="ot">-&gt;</span> q <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
 <p>You’ll find an example program that uses sqlite-simple to maintain a phone book under <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/Phonebook.hs"><code>exercises/Examples/Phonebook.hs</code></a>. The program keeps the phonebook in a file called <code>phonebook.db</code> and works like this (run from the <code>exercises/Examples</code> directory in the course repository):</p>
 <pre><code>$ stack runhaskell Phonebook.hs
 (a)dd or (q)uery?
@@ -3760,50 +3758,50 @@ bob
 <li>Necessity: there just is no way to define a <code>Monad</code> instance for your type, but there is an <code>Applicative</code> instance. This is rare.</li>
 </ul>
 <p>So what is an <code>Applicative</code>? Let’s look at a definition.</p>
-<div class="sourceCode" id="cb338"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb338-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> <span class="dt">Applicative</span> f <span class="kw">where</span></a>
-<a class="sourceLine" id="cb338-2" data-line-number="2"><span class="ot">  pure ::</span> a <span class="ot">-&gt;</span> f a</a>
-<a class="sourceLine" id="cb338-3" data-line-number="3"><span class="ot">  liftA2 ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f c</a>
-<a class="sourceLine" id="cb338-4" data-line-number="4">  <span class="co">-- other operations omitted for now</span></a></code></pre></div>
+<div class="sourceCode" id="cb338"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb338-1" title="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> <span class="dt">Applicative</span> f <span class="kw">where</span></a>
+<a class="sourceLine" id="cb338-2" title="2"><span class="ot">  pure ::</span> a <span class="ot">-&gt;</span> f a</a>
+<a class="sourceLine" id="cb338-3" title="3"><span class="ot">  liftA2 ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f c</a>
+<a class="sourceLine" id="cb338-4" title="4">  <span class="co">-- other operations omitted for now</span></a></code></pre></div>
 <p>So an <code>Applicative</code> is a <code>Functor</code> that allows us to build singleton values via <code>pure</code>, and combine two values into one using <code>liftA2</code>. This adds a lot of power compared to a bare functor. Computations using functors are necessarily linear: <code>fmap :: (a -&gt; b) -&gt; f a -&gt; f b</code> takes in one functorial value, and outputs another. By contrast, <code>pure</code> takes in no functorial value and outputs one, and <code>liftA2</code> takes in two and returns one.</p>
 <p>Sidenote: the term Applicative comes from the term <a href="https://en.wikipedia.org/wiki/Applicative_functor">Applicative Functor</a>, which sounds like it comes from Category Theory, but was actually introduced in a programming paper.</p>
 <p>That’s enough abstract mumbo jumbo for now. Let’s look at what sort of computations we can express using Applicative operations (and <code>fmap</code>). We’ll start with the <code>Maybe</code> applicative. Here’s a streamlined definition:</p>
-<div class="sourceCode" id="cb339"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb339-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb339-2" data-line-number="2">  pure x <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb339-3" data-line-number="3">  liftA2 f (<span class="dt">Just</span> x) (<span class="dt">Just</span> y) <span class="fu">=</span> <span class="dt">Just</span> (f x y)</a>
-<a class="sourceLine" id="cb339-4" data-line-number="4">  liftA2 f _        _        <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb339"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb339-1" title="1"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb339-2" title="2">  <span class="fu">pure</span> x <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb339-3" title="3">  liftA2 f (<span class="dt">Just</span> x) (<span class="dt">Just</span> y) <span class="fu">=</span> <span class="dt">Just</span> (f x y)</a>
+<a class="sourceLine" id="cb339-4" title="4">  liftA2 f _        _        <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
 <!-- TODO some GHCi examples? -->
 <p>You’ll see the definition uses the same type of failure propagation as the <code>Monad Maybe</code> instance. Let’s use this when parsing monetary values:</p>
-<div class="sourceCode" id="cb340"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb340-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Currency</span> <span class="fu">=</span> <span class="dt">EUR</span> <span class="fu">|</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb340-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb340-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span> <span class="dt">Currency</span></a>
-<a class="sourceLine" id="cb340-4" data-line-number="4">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb340-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb340-6" data-line-number="6"><span class="ot">parseCurrency ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Currency</span></a>
-<a class="sourceLine" id="cb340-7" data-line-number="7">parseCurrency <span class="st">&quot;e&quot;</span> <span class="fu">=</span> pure <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb340-8" data-line-number="8">parseCurrency <span class="st">&quot;€&quot;</span> <span class="fu">=</span> pure <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb340-9" data-line-number="9">parseCurrency <span class="st">&quot;$&quot;</span> <span class="fu">=</span> pure <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb340-10" data-line-number="10">parseCurrency _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb340-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb340-12" data-line-number="12"><span class="ot">parseAmount ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb340-13" data-line-number="13">parseAmount <span class="fu">=</span> readMaybe</a>
-<a class="sourceLine" id="cb340-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb340-15" data-line-number="15"><span class="ot">parseMoney ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb340-16" data-line-number="16">parseMoney amountString currencyString <span class="fu">=</span></a>
-<a class="sourceLine" id="cb340-17" data-line-number="17">  liftA2 <span class="dt">Money</span> (parseAmount amountString) (parseCurrency currencyString)</a></code></pre></div>
-<div class="sourceCode" id="cb341"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb341-1" data-line-number="1">parseMoney <span class="st">&quot;123&quot;</span> <span class="st">&quot;€&quot;</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Money</span> <span class="dv">123</span> <span class="dt">EUR</span>)</a>
-<a class="sourceLine" id="cb341-2" data-line-number="2">parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;$&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Money</span> <span class="dv">45</span> <span class="dt">USD</span>)</a>
-<a class="sourceLine" id="cb341-3" data-line-number="3">parseMoney <span class="st">&quot;4x&quot;</span> <span class="st">&quot;€&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb341-4" data-line-number="4">parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;£&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb340"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb340-1" title="1"><span class="kw">data</span> <span class="dt">Currency</span> <span class="fu">=</span> <span class="dt">EUR</span> <span class="fu">|</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb340-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb340-3" title="3"><span class="kw">data</span> <span class="dt">Money</span> <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Int</span> <span class="dt">Currency</span></a>
+<a class="sourceLine" id="cb340-4" title="4">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb340-5" title="5"></a>
+<a class="sourceLine" id="cb340-6" title="6"><span class="ot">parseCurrency ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Currency</span></a>
+<a class="sourceLine" id="cb340-7" title="7">parseCurrency <span class="st">&quot;e&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb340-8" title="8">parseCurrency <span class="st">&quot;€&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb340-9" title="9">parseCurrency <span class="st">&quot;$&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb340-10" title="10">parseCurrency _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb340-11" title="11"></a>
+<a class="sourceLine" id="cb340-12" title="12"><span class="ot">parseAmount ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb340-13" title="13">parseAmount <span class="fu">=</span> readMaybe</a>
+<a class="sourceLine" id="cb340-14" title="14"></a>
+<a class="sourceLine" id="cb340-15" title="15"><span class="ot">parseMoney ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb340-16" title="16">parseMoney amountString currencyString <span class="fu">=</span></a>
+<a class="sourceLine" id="cb340-17" title="17">  liftA2 <span class="dt">Money</span> (parseAmount amountString) (parseCurrency currencyString)</a></code></pre></div>
+<div class="sourceCode" id="cb341"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb341-1" title="1">parseMoney <span class="st">&quot;123&quot;</span> <span class="st">&quot;€&quot;</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Money</span> <span class="dv">123</span> <span class="dt">EUR</span>)</a>
+<a class="sourceLine" id="cb341-2" title="2">parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;$&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Money</span> <span class="dv">45</span> <span class="dt">USD</span>)</a>
+<a class="sourceLine" id="cb341-3" title="3">parseMoney <span class="st">&quot;4x&quot;</span> <span class="st">&quot;€&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb341-4" title="4">parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;£&quot;</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>That worked out nicely. However, if we try to expand on this we soon run into the limits of <code>Applicative</code>. For example, consider this <code>sumMoney</code> function that sums <code>Money</code> values but fails if they are not in the same currency:</p>
-<div class="sourceCode" id="cb342"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb342-1" data-line-number="1"><span class="ot">sumMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb342-2" data-line-number="2">sumMoney (<span class="dt">Money</span> a c) (<span class="dt">Money</span> b c&#39;)</a>
-<a class="sourceLine" id="cb342-3" data-line-number="3">    <span class="fu">|</span> c <span class="fu">==</span> c&#39;   <span class="fu">=</span> <span class="dt">Just</span> (<span class="dt">Money</span> (a<span class="fu">+</span>b) c)</a>
-<a class="sourceLine" id="cb342-4" data-line-number="4">    <span class="fu">|</span> otherwise <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb342"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb342-1" title="1"><span class="ot">sumMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb342-2" title="2">sumMoney (<span class="dt">Money</span> a c) (<span class="dt">Money</span> b c&#39;)</a>
+<a class="sourceLine" id="cb342-3" title="3">    <span class="fu">|</span> c <span class="fu">==</span> c&#39;   <span class="fu">=</span> <span class="dt">Just</span> (<span class="dt">Money</span> (a<span class="fu">+</span>b) c)</a>
+<a class="sourceLine" id="cb342-4" title="4">    <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>We can’t apply it to two <code>Maybe Money</code> values using <code>Applicative</code> operations. We need the <code>Maybe</code> monad for that:</p>
-<div class="sourceCode" id="cb343"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb343-1" data-line-number="1"><span class="ot">example ::</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb343-2" data-line-number="2">example <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> parseMoney <span class="st">&quot;123&quot;</span> <span class="st">&quot;€&quot;</span></a>
-<a class="sourceLine" id="cb343-3" data-line-number="3">             y <span class="ot">&lt;-</span> parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;$&quot;</span></a>
-<a class="sourceLine" id="cb343-4" data-line-number="4">             sumMoney x y</a></code></pre></div>
+<div class="sourceCode" id="cb343"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb343-1" title="1"><span class="ot">example ::</span> <span class="dt">Maybe</span> <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb343-2" title="2">example <span class="fu">=</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> parseMoney <span class="st">&quot;123&quot;</span> <span class="st">&quot;€&quot;</span></a>
+<a class="sourceLine" id="cb343-3" title="3">             y <span class="ot">&lt;-</span> parseMoney <span class="st">&quot;45&quot;</span> <span class="st">&quot;$&quot;</span></a>
+<a class="sourceLine" id="cb343-4" title="4">             sumMoney x y</a></code></pre></div>
 <p>If we try to use <code>liftA2</code>, we’re stuck with a <code>Maybe (Maybe Money)</code> type. In addition, we can now get two different types of failures: <code>Nothing</code> and <code>Just Nothing</code>, depending on what level the error happens on. This would be a clear case for switching to a <code>Monad</code> instance.</p>
 <pre><code>liftA2 sumMoney (parseMoney &quot;123&quot; &quot;e&quot;) (parseMoney &quot;45&quot; &quot;€&quot;)
   ==&gt; Just (Just (Money 168 EUR))
@@ -3814,332 +3812,332 @@ liftA2 sumMoney (parseMoney &quot;123&quot; &quot;e&quot;) (parseMoney &quot;xxx
 <p>Sidenote: the name <code>liftA2</code> sounds a bit cumbersome, but it’s an analogy with the <code>liftM</code>, <code>liftM2</code> and so on functions for monads. Recall that <code>liftM</code> was just <code>fmap</code>, so perhaps <code>liftA2</code> should’ve been called <code>fmap2</code>.</p>
 <h2 id="the-list-applicative"><span class="header-section-number">15.2</span> The List Applicative</h2>
 <p>Let’s have a look at the applicative instances for another <code>Functor</code> we’ve seen. The <code>Applicative</code> instance for the list functor goes through all possible combinations of values (just like the list monad). Here’s the instance:</p>
-<div class="sourceCode" id="cb345"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb345-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Applicative</span> [] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb345-2" data-line-number="2">  pure x <span class="fu">=</span> [x]</a>
-<a class="sourceLine" id="cb345-3" data-line-number="3">  liftA2 f xs ys <span class="fu">=</span> [f x y <span class="fu">|</span> x <span class="ot">&lt;-</span> xs, y <span class="ot">&lt;-</span> ys]</a></code></pre></div>
+<div class="sourceCode" id="cb345"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb345-1" title="1"><span class="kw">instance</span> <span class="dt">Applicative</span> [] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb345-2" title="2">  <span class="fu">pure</span> x <span class="fu">=</span> [x]</a>
+<a class="sourceLine" id="cb345-3" title="3">  liftA2 f xs ys <span class="fu">=</span> [f x y <span class="fu">|</span> x <span class="ot">&lt;-</span> xs, y <span class="ot">&lt;-</span> ys]</a></code></pre></div>
 <p>And here’s an example: generating some phrases.</p>
-<div class="sourceCode" id="cb346"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb346-1" data-line-number="1"><span class="ot">things ::</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb346-2" data-line-number="2">things <span class="fu">=</span> [<span class="st">&quot;tangerine&quot;</span>,<span class="st">&quot;bandit&quot;</span>,<span class="st">&quot;diamond&quot;</span>]</a>
-<a class="sourceLine" id="cb346-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb346-4" data-line-number="4"><span class="ot">fruits ::</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb346-5" data-line-number="5">fruits <span class="fu">=</span> [<span class="st">&quot;apple&quot;</span>, <span class="st">&quot;tangerine&quot;</span>]</a>
-<a class="sourceLine" id="cb346-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb346-7" data-line-number="7"><span class="ot">phrases ::</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb346-8" data-line-number="8">phrases <span class="fu">=</span> liftA2 combine things fruits</a>
-<a class="sourceLine" id="cb346-9" data-line-number="9">  <span class="kw">where</span> combine t f <span class="fu">=</span> <span class="st">&quot;a &quot;</span> <span class="fu">++</span> t <span class="fu">++</span> <span class="st">&quot; the size of a &quot;</span> <span class="fu">++</span> f</a>
-<a class="sourceLine" id="cb346-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb346-11" data-line-number="11">bunches <span class="fu">=</span> liftA2 copy [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] fruits</a>
-<a class="sourceLine" id="cb346-12" data-line-number="12">  <span class="kw">where</span> copy n f <span class="fu">=</span> unwords (replicate n f)</a></code></pre></div>
-<div class="sourceCode" id="cb347"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb347-1" data-line-number="1">phrases <span class="fu">==&gt;</span> [<span class="st">&quot;a tangerine the size of a apple&quot;</span>,</a>
-<a class="sourceLine" id="cb347-2" data-line-number="2">             <span class="st">&quot;a tangerine the size of a tangerine&quot;</span>,</a>
-<a class="sourceLine" id="cb347-3" data-line-number="3">             <span class="st">&quot;a bandit the size of a apple&quot;</span>,</a>
-<a class="sourceLine" id="cb347-4" data-line-number="4">             <span class="st">&quot;a bandit the size of a tangerine&quot;</span>,</a>
-<a class="sourceLine" id="cb347-5" data-line-number="5">             <span class="st">&quot;a diamond the size of a apple&quot;</span>,</a>
-<a class="sourceLine" id="cb347-6" data-line-number="6">             <span class="st">&quot;a diamond the size of a tangerine&quot;</span>]</a>
-<a class="sourceLine" id="cb347-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb347-8" data-line-number="8">bunches <span class="fu">==&gt;</span> [<span class="st">&quot;apple&quot;</span>,<span class="st">&quot;tangerine&quot;</span>,</a>
-<a class="sourceLine" id="cb347-9" data-line-number="9">             <span class="st">&quot;apple apple&quot;</span>,<span class="st">&quot;tangerine tangerine&quot;</span>,</a>
-<a class="sourceLine" id="cb347-10" data-line-number="10">             <span class="st">&quot;apple apple apple&quot;</span>,<span class="st">&quot;tangerine tangerine tangerine&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb346"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb346-1" title="1"><span class="ot">things ::</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb346-2" title="2">things <span class="fu">=</span> [<span class="st">&quot;tangerine&quot;</span>,<span class="st">&quot;bandit&quot;</span>,<span class="st">&quot;diamond&quot;</span>]</a>
+<a class="sourceLine" id="cb346-3" title="3"></a>
+<a class="sourceLine" id="cb346-4" title="4"><span class="ot">fruits ::</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb346-5" title="5">fruits <span class="fu">=</span> [<span class="st">&quot;apple&quot;</span>, <span class="st">&quot;tangerine&quot;</span>]</a>
+<a class="sourceLine" id="cb346-6" title="6"></a>
+<a class="sourceLine" id="cb346-7" title="7"><span class="ot">phrases ::</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb346-8" title="8">phrases <span class="fu">=</span> liftA2 combine things fruits</a>
+<a class="sourceLine" id="cb346-9" title="9">  <span class="kw">where</span> combine t f <span class="fu">=</span> <span class="st">&quot;a &quot;</span> <span class="fu">++</span> t <span class="fu">++</span> <span class="st">&quot; the size of a &quot;</span> <span class="fu">++</span> f</a>
+<a class="sourceLine" id="cb346-10" title="10"></a>
+<a class="sourceLine" id="cb346-11" title="11">bunches <span class="fu">=</span> liftA2 copy [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] fruits</a>
+<a class="sourceLine" id="cb346-12" title="12">  <span class="kw">where</span> copy n f <span class="fu">=</span> <span class="fu">unwords</span> (<span class="fu">replicate</span> n f)</a></code></pre></div>
+<div class="sourceCode" id="cb347"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb347-1" title="1">phrases <span class="fu">==&gt;</span> [<span class="st">&quot;a tangerine the size of a apple&quot;</span>,</a>
+<a class="sourceLine" id="cb347-2" title="2">             <span class="st">&quot;a tangerine the size of a tangerine&quot;</span>,</a>
+<a class="sourceLine" id="cb347-3" title="3">             <span class="st">&quot;a bandit the size of a apple&quot;</span>,</a>
+<a class="sourceLine" id="cb347-4" title="4">             <span class="st">&quot;a bandit the size of a tangerine&quot;</span>,</a>
+<a class="sourceLine" id="cb347-5" title="5">             <span class="st">&quot;a diamond the size of a apple&quot;</span>,</a>
+<a class="sourceLine" id="cb347-6" title="6">             <span class="st">&quot;a diamond the size of a tangerine&quot;</span>]</a>
+<a class="sourceLine" id="cb347-7" title="7"></a>
+<a class="sourceLine" id="cb347-8" title="8">bunches <span class="fu">==&gt;</span> [<span class="st">&quot;apple&quot;</span>,<span class="st">&quot;tangerine&quot;</span>,</a>
+<a class="sourceLine" id="cb347-9" title="9">             <span class="st">&quot;apple apple&quot;</span>,<span class="st">&quot;tangerine tangerine&quot;</span>,</a>
+<a class="sourceLine" id="cb347-10" title="10">             <span class="st">&quot;apple apple apple&quot;</span>,<span class="st">&quot;tangerine tangerine tangerine&quot;</span>]</a></code></pre></div>
 <!-- TODO more examples? -->
 <h2 id="new-operators"><span class="header-section-number">15.3</span> New Operators</h2>
 <p>There are a handful of operators for Applicatives that are quite handy. They are <code>&lt;$&gt;</code>, <code>&lt;*&gt;</code>, <code>&lt;*</code> and <code>*&gt;</code>.</p>
 <p>Let’s start with <code>&lt;$&gt;</code>, which is just an infix version of <code>fmap</code>:</p>
-<div class="sourceCode" id="cb348"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb348-1" data-line-number="1"><span class="ot">(&lt;$&gt;) ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb348-2" data-line-number="2">f <span class="fu">&lt;$&gt;</span> x <span class="fu">=</span> fmap f x</a></code></pre></div>
-<div class="sourceCode" id="cb349"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb349-1" data-line-number="1">not <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb349-2" data-line-number="2">not <span class="fu">&lt;$&gt;</span> <span class="dt">Nothing</span>     <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb349-3" data-line-number="3">negate <span class="fu">&lt;$&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">3</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb348"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb348-1" title="1"><span class="ot">(&lt;$&gt;) ::</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb348-2" title="2">f <span class="fu">&lt;$&gt;</span> x <span class="fu">=</span> <span class="fu">fmap</span> f x</a></code></pre></div>
+<div class="sourceCode" id="cb349"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb349-1" title="1"><span class="fu">not</span> <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb349-2" title="2"><span class="fu">not</span> <span class="fu">&lt;$&gt;</span> <span class="dt">Nothing</span>     <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb349-3" title="3"><span class="fu">negate</span> <span class="fu">&lt;$&gt;</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]  <span class="fu">==&gt;</span> [<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="fu">-</span><span class="dv">3</span>]</a></code></pre></div>
 <p>That’s kinda nice on its own, but it really gets to shine when combined with this Applicative operator:</p>
-<div class="sourceCode" id="cb350"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb350-1" data-line-number="1"><span class="ot">(&lt;*&gt;) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
+<div class="sourceCode" id="cb350"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb350-1" title="1"><span class="ot">(&lt;*&gt;) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a></code></pre></div>
 <p>The type tells you what <code>&lt;*&gt;</code> does: it’s function application <em>lifted</em> to an applicative. Here are some standalone examples:</p>
-<div class="sourceCode" id="cb351"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb351-1" data-line-number="1"><span class="dt">Just</span> not <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>    <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">False</span></a>
-<a class="sourceLine" id="cb351-2" data-line-number="2"><span class="dt">Nothing</span>  <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb351-3" data-line-number="3"><span class="dt">Just</span> not <span class="fu">&lt;*&gt;</span> <span class="dt">Nothing</span>      <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb351-4" data-line-number="4">[(<span class="fu">+</span><span class="dv">1</span>),(<span class="fu">*</span><span class="dv">2</span>)] <span class="fu">&lt;*&gt;</span> [<span class="dv">10</span>,<span class="dv">100</span>]  <span class="fu">==&gt;</span> [<span class="dv">11</span>,<span class="dv">101</span>,<span class="dv">20</span>,<span class="dv">200</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb351"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb351-1" title="1"><span class="dt">Just</span> <span class="fu">not</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>    <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">False</span></a>
+<a class="sourceLine" id="cb351-2" title="2"><span class="dt">Nothing</span>  <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dt">True</span>    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb351-3" title="3"><span class="dt">Just</span> <span class="fu">not</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Nothing</span>      <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb351-4" title="4">[(<span class="fu">+</span><span class="dv">1</span>),(<span class="fu">*</span><span class="dv">2</span>)] <span class="fu">&lt;*&gt;</span> [<span class="dv">10</span>,<span class="dv">100</span>]  <span class="fu">==&gt;</span> [<span class="dv">11</span>,<span class="dv">101</span>,<span class="dv">20</span>,<span class="dv">200</span>]</a></code></pre></div>
 <p>The real magic happens when we combine <code>&lt;$&gt;</code> and <code>&lt;*&gt;</code>: we can then lift functions of arbitrarily many argments to an Applicative!</p>
-<div class="sourceCode" id="cb352"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb352-1" data-line-number="1"><span class="ot">say ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb352-2" data-line-number="2">say x i y <span class="fu">=</span> x <span class="fu">++</span> <span class="st">&quot; has &quot;</span> <span class="fu">++</span> show i <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> y</a></code></pre></div>
-<div class="sourceCode" id="cb353"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb353-1" data-line-number="1">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb353-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell has 99 operators&quot;</span></a>
-<a class="sourceLine" id="cb353-3" data-line-number="3">say <span class="fu">&lt;$&gt;</span> <span class="dt">Nothing</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb353-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb353-5" data-line-number="5">say <span class="fu">&lt;$&gt;</span> [<span class="st">&quot;bob&quot;</span>,<span class="st">&quot;jake&quot;</span>] <span class="fu">&lt;*&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&lt;*&gt;</span> [<span class="st">&quot;bananas&quot;</span>,<span class="st">&quot;cars&quot;</span>]</a>
-<a class="sourceLine" id="cb353-6" data-line-number="6">  <span class="fu">==&gt;</span> [<span class="st">&quot;bob has 2 bananas&quot;</span>,</a>
-<a class="sourceLine" id="cb353-7" data-line-number="7">       <span class="st">&quot;bob has 2 cars&quot;</span>,</a>
-<a class="sourceLine" id="cb353-8" data-line-number="8">       <span class="st">&quot;bob has 3 bananas&quot;</span>,</a>
-<a class="sourceLine" id="cb353-9" data-line-number="9">       <span class="st">&quot;bob has 3 cars&quot;</span>,</a>
-<a class="sourceLine" id="cb353-10" data-line-number="10">       <span class="st">&quot;jake has 2 bananas&quot;</span>,</a>
-<a class="sourceLine" id="cb353-11" data-line-number="11">       <span class="st">&quot;jake has 2 cars&quot;</span>,</a>
-<a class="sourceLine" id="cb353-12" data-line-number="12">       <span class="st">&quot;jake has 3 bananas&quot;</span>,</a>
-<a class="sourceLine" id="cb353-13" data-line-number="13">       <span class="st">&quot;jake has 3 cars&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb352"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb352-1" title="1"><span class="ot">say ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb352-2" title="2">say x i y <span class="fu">=</span> x <span class="fu">++</span> <span class="st">&quot; has &quot;</span> <span class="fu">++</span> <span class="fu">show</span> i <span class="fu">++</span> <span class="st">&quot; &quot;</span> <span class="fu">++</span> y</a></code></pre></div>
+<div class="sourceCode" id="cb353"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb353-1" title="1">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb353-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell has 99 operators&quot;</span></a>
+<a class="sourceLine" id="cb353-3" title="3">say <span class="fu">&lt;$&gt;</span> <span class="dt">Nothing</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb353-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb353-5" title="5">say <span class="fu">&lt;$&gt;</span> [<span class="st">&quot;bob&quot;</span>,<span class="st">&quot;jake&quot;</span>] <span class="fu">&lt;*&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">&lt;*&gt;</span> [<span class="st">&quot;bananas&quot;</span>,<span class="st">&quot;cars&quot;</span>]</a>
+<a class="sourceLine" id="cb353-6" title="6">  <span class="fu">==&gt;</span> [<span class="st">&quot;bob has 2 bananas&quot;</span>,</a>
+<a class="sourceLine" id="cb353-7" title="7">       <span class="st">&quot;bob has 2 cars&quot;</span>,</a>
+<a class="sourceLine" id="cb353-8" title="8">       <span class="st">&quot;bob has 3 bananas&quot;</span>,</a>
+<a class="sourceLine" id="cb353-9" title="9">       <span class="st">&quot;bob has 3 cars&quot;</span>,</a>
+<a class="sourceLine" id="cb353-10" title="10">       <span class="st">&quot;jake has 2 bananas&quot;</span>,</a>
+<a class="sourceLine" id="cb353-11" title="11">       <span class="st">&quot;jake has 2 cars&quot;</span>,</a>
+<a class="sourceLine" id="cb353-12" title="12">       <span class="st">&quot;jake has 3 bananas&quot;</span>,</a>
+<a class="sourceLine" id="cb353-13" title="13">       <span class="st">&quot;jake has 3 cars&quot;</span>]</a></code></pre></div>
 <p>What’s going on here? Let’s step through the evaluation. The key is that each <code>&lt;*&gt;</code> partially applies one more argument to the function.</p>
-<div class="sourceCode" id="cb354"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb354-1" data-line-number="1">    say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb354-2" data-line-number="2"><span class="fu">===</span> ((say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb354-3" data-line-number="3"><span class="fu">===</span> (fmap say (<span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb354-4" data-line-number="4"><span class="fu">==&gt;</span> (<span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb354-5" data-line-number="5"><span class="fu">==&gt;</span> <span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
-<a class="sourceLine" id="cb354-6" data-line-number="6"><span class="fu">==&gt;</span> <span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span> <span class="dv">99</span> <span class="st">&quot;operators&quot;</span>)</a>
-<a class="sourceLine" id="cb354-7" data-line-number="7"><span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell has 99 operators&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb354"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb354-1" title="1">    say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb354-2" title="2"><span class="fu">===</span> ((say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb354-3" title="3"><span class="fu">===</span> (<span class="fu">fmap</span> say (<span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb354-4" title="4"><span class="fu">==&gt;</span> (<span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb354-5" title="5"><span class="fu">==&gt;</span> <span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span> <span class="dv">99</span>) <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span></a>
+<a class="sourceLine" id="cb354-6" title="6"><span class="fu">==&gt;</span> <span class="dt">Just</span> (say <span class="st">&quot;haskell&quot;</span> <span class="dv">99</span> <span class="st">&quot;operators&quot;</span>)</a>
+<a class="sourceLine" id="cb354-7" title="7"><span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell has 99 operators&quot;</span></a></code></pre></div>
 <p>Perhaps looking at the types will make it clearer:</p>
-<div class="sourceCode" id="cb355"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb355-1" data-line-number="1">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span><span class="ot">                                  ::</span> <span class="dt">Maybe</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span>)</a>
-<a class="sourceLine" id="cb355-2" data-line-number="2">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span><span class="ot">                      ::</span> <span class="dt">Maybe</span> (       <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span>)</a>
-<a class="sourceLine" id="cb355-3" data-line-number="3">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> (                 <span class="dt">String</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb355"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb355-1" title="1">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span><span class="ot">                                  ::</span> <span class="dt">Maybe</span> (<span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span>)</a>
+<a class="sourceLine" id="cb355-2" title="2">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span><span class="ot">                      ::</span> <span class="dt">Maybe</span> (       <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span>)</a>
+<a class="sourceLine" id="cb355-3" title="3">say <span class="fu">&lt;$&gt;</span> <span class="dt">Just</span> <span class="st">&quot;haskell&quot;</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="dv">99</span> <span class="fu">&lt;*&gt;</span> <span class="dt">Just</span> <span class="st">&quot;operators&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> (                 <span class="dt">String</span>)</a></code></pre></div>
 <p>The next two operators are a bit simpler:</p>
-<div class="sourceCode" id="cb356"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb356-1" data-line-number="1"><span class="ot">(*&gt;) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb356-2" data-line-number="2">x <span class="fu">*&gt;</span> y <span class="fu">=</span> liftA2 (\a b <span class="ot">-&gt;</span> b) x y</a>
-<a class="sourceLine" id="cb356-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb356-4" data-line-number="4"><span class="ot">(&lt;*) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f a</a>
-<a class="sourceLine" id="cb356-5" data-line-number="5">x <span class="fu">&lt;*</span> y <span class="fu">=</span> liftA2 (\a b <span class="ot">-&gt;</span> a) x y</a></code></pre></div>
+<div class="sourceCode" id="cb356"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb356-1" title="1"><span class="ot">(*&gt;) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb356-2" title="2">x <span class="fu">*&gt;</span> y <span class="fu">=</span> liftA2 (\a b <span class="ot">-&gt;</span> b) x y</a>
+<a class="sourceLine" id="cb356-3" title="3"></a>
+<a class="sourceLine" id="cb356-4" title="4"><span class="ot">(&lt;*) ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f a</a>
+<a class="sourceLine" id="cb356-5" title="5">x <span class="fu">&lt;*</span> y <span class="fu">=</span> liftA2 (\a b <span class="ot">-&gt;</span> a) x y</a></code></pre></div>
 <p>You can compare the types to a more familiar operator:</p>
-<div class="sourceCode" id="cb357"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb357-1" data-line-number="1"><span class="ot">(&gt;&gt;) ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m a <span class="ot">-&gt;</span> m b <span class="ot">-&gt;</span> m b</a></code></pre></div>
+<div class="sourceCode" id="cb357"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb357-1" title="1"><span class="ot">(&gt;&gt;) ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> m a <span class="ot">-&gt;</span> m b <span class="ot">-&gt;</span> m b</a></code></pre></div>
 <p>What the operators <code>&lt;*</code> and <code>*&gt;</code> mean is: run both of these operations, but only keep one result. The arrow points to the result that’s kept:</p>
-<div class="sourceCode" id="cb358"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb358-1" data-line-number="1"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">*&gt;</span> <span class="dt">Just</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
-<a class="sourceLine" id="cb358-2" data-line-number="2"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&lt;*</span> <span class="dt">Just</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb358-3" data-line-number="3"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&lt;*</span> <span class="dt">Nothing</span> <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb358-4" data-line-number="4"><span class="dt">Nothing</span> <span class="fu">&lt;*</span> <span class="dt">Just</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb358"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb358-1" title="1"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">*&gt;</span> <span class="dt">Just</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">2</span></a>
+<a class="sourceLine" id="cb358-2" title="2"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&lt;*</span> <span class="dt">Just</span> <span class="dv">2</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb358-3" title="3"><span class="dt">Just</span> <span class="dv">1</span> <span class="fu">&lt;*</span> <span class="dt">Nothing</span> <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb358-4" title="4"><span class="dt">Nothing</span> <span class="fu">&lt;*</span> <span class="dt">Just</span> <span class="dv">2</span> <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>These operators might seem trivial, but they’re useful when combining checks. For example:</p>
-<div class="sourceCode" id="cb359"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb359-1" data-line-number="1"><span class="ot">decrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb359-2" data-line-number="2">decrease i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> (i<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb359-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb359-4" data-line-number="4"><span class="ot">small ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb359-5" data-line-number="5">small i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&lt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dt">Just</span> i <span class="kw">else</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb359-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb359-7" data-line-number="7"><span class="ot">decreaseSmall ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb359-8" data-line-number="8"><span class="co">-- do what decrease does, but fail if small fails</span></a>
-<a class="sourceLine" id="cb359-9" data-line-number="9">decreaseSmall i <span class="fu">=</span> decrease i <span class="fu">&lt;*</span> small i</a></code></pre></div>
-<div class="sourceCode" id="cb360"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb360-1" data-line-number="1">decreaseSmall <span class="dv">4</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb360-2" data-line-number="2">decreaseSmall <span class="dv">0</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb360-3" data-line-number="3">decreaseSmall <span class="dv">11</span>  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb359"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb359-1" title="1"><span class="ot">decrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb359-2" title="2">decrease i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> (i<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb359-3" title="3"></a>
+<a class="sourceLine" id="cb359-4" title="4"><span class="ot">small ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb359-5" title="5">small i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&lt;</span><span class="dv">10</span> <span class="kw">then</span> <span class="dt">Just</span> i <span class="kw">else</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb359-6" title="6"></a>
+<a class="sourceLine" id="cb359-7" title="7"><span class="ot">decreaseSmall ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb359-8" title="8"><span class="co">-- do what decrease does, but fail if small fails</span></a>
+<a class="sourceLine" id="cb359-9" title="9">decreaseSmall i <span class="fu">=</span> decrease i <span class="fu">&lt;*</span> small i</a></code></pre></div>
+<div class="sourceCode" id="cb360"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb360-1" title="1">decreaseSmall <span class="dv">4</span>   <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb360-2" title="2">decreaseSmall <span class="dv">0</span>   <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb360-3" title="3">decreaseSmall <span class="dv">11</span>  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>Now that we’ve seen all these operators, we can understand the full definition of <code>Applicative</code>. All the operators have definitions in terms of <code>liftA2</code>, so it’s enought to define <code>liftA2</code> and <code>pure</code> when implementing an <code>Applicative</code> instance.</p>
-<div class="sourceCode" id="cb361"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb361-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> <span class="dt">Applicative</span> f <span class="kw">where</span></a>
-<a class="sourceLine" id="cb361-2" data-line-number="2"><span class="ot">  pure ::</span> a <span class="ot">-&gt;</span> f a</a>
-<a class="sourceLine" id="cb361-3" data-line-number="3"><span class="ot">  liftA2 ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f c</a>
-<a class="sourceLine" id="cb361-4" data-line-number="4"><span class="ot">  (&lt;*&gt;) ::</span> f (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb361-5" data-line-number="5"><span class="ot">  (*&gt;) ::</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f b</a>
-<a class="sourceLine" id="cb361-6" data-line-number="6"><span class="ot">  (&lt;*) ::</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f a</a></code></pre></div>
+<div class="sourceCode" id="cb361"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb361-1" title="1"><span class="kw">class</span> <span class="dt">Functor</span> f <span class="ot">=&gt;</span> <span class="dt">Applicative</span> f <span class="kw">where</span></a>
+<a class="sourceLine" id="cb361-2" title="2"><span class="ot">  pure ::</span> a <span class="ot">-&gt;</span> f a</a>
+<a class="sourceLine" id="cb361-3" title="3"><span class="ot">  liftA2 ::</span> (a <span class="ot">-&gt;</span> b <span class="ot">-&gt;</span> c) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f c</a>
+<a class="sourceLine" id="cb361-4" title="4"><span class="ot">  (&lt;*&gt;) ::</span> f (a <span class="ot">-&gt;</span> b) <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb361-5" title="5"><span class="ot">  (*&gt;) ::</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f b</a>
+<a class="sourceLine" id="cb361-6" title="6"><span class="ot">  (&lt;*) ::</span> f a <span class="ot">-&gt;</span> f b <span class="ot">-&gt;</span> f a</a></code></pre></div>
 <h2 id="the-validation-applicative"><span class="header-section-number">15.4</span> The Validation Applicative</h2>
 <p>Let’s look at an Applicative that’s a bit more interesting than Maybe or lists. Often in programming we need to <em>validate</em> some inputs from the user. In these cases it’s useful to gather together all the errors that the input might have. The file <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/Validation.hs"><code>exercises/Examples/Validation.hs</code></a> implements the <code>Validation</code> datatype:</p>
-<div class="sourceCode" id="cb362"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb362-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Validation</span> a <span class="fu">=</span> <span class="dt">Ok</span> a <span class="fu">|</span> <span class="dt">Errors</span> [<span class="dt">String</span>]</a>
-<a class="sourceLine" id="cb362-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>,<span class="dt">Eq</span>)</a></code></pre></div>
+<div class="sourceCode" id="cb362"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb362-1" title="1"><span class="kw">data</span> <span class="dt">Validation</span> a <span class="fu">=</span> <span class="dt">Ok</span> a <span class="fu">|</span> <span class="dt">Errors</span> [<span class="dt">String</span>]</a>
+<a class="sourceLine" id="cb362-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>,<span class="dt">Eq</span>)</a></code></pre></div>
 <p>The <code>Applicative</code> instance for <code>Validation</code> works like this:</p>
-<div class="sourceCode" id="cb363"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb363-1" data-line-number="1">liftA2 (<span class="fu">+</span>) (<span class="dt">Ok</span> <span class="dv">1</span>) (<span class="dt">Ok</span> <span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb363-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> <span class="dv">3</span></a>
-<a class="sourceLine" id="cb363-3" data-line-number="3">liftA2 (<span class="fu">+</span>) (<span class="dt">Errors</span> [<span class="st">&quot;oh no&quot;</span>]) (<span class="dt">Errors</span> [<span class="st">&quot;boom&quot;</span>])</a>
-<a class="sourceLine" id="cb363-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;oh no&quot;</span>,<span class="st">&quot;boom&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb363"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb363-1" title="1">liftA2 (<span class="fu">+</span>) (<span class="dt">Ok</span> <span class="dv">1</span>) (<span class="dt">Ok</span> <span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb363-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> <span class="dv">3</span></a>
+<a class="sourceLine" id="cb363-3" title="3">liftA2 (<span class="fu">+</span>) (<span class="dt">Errors</span> [<span class="st">&quot;oh no&quot;</span>]) (<span class="dt">Errors</span> [<span class="st">&quot;boom&quot;</span>])</a>
+<a class="sourceLine" id="cb363-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;oh no&quot;</span>,<span class="st">&quot;boom&quot;</span>]</a></code></pre></div>
 <p>Note how in contrast to the <code>Maybe</code> Applicative, we have many different kinds of failures.</p>
 <p>Here’s a worked example that introduces some helpers and then uses them to congratulate somebody on their birthday:</p>
-<div class="sourceCode" id="cb364"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb364-1" data-line-number="1"><span class="ot">invalid ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> a</a>
-<a class="sourceLine" id="cb364-2" data-line-number="2">invalid err <span class="fu">=</span> <span class="dt">Errors</span> [err]</a>
-<a class="sourceLine" id="cb364-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb364-4" data-line-number="4"><span class="ot">check ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Validation</span> a</a>
-<a class="sourceLine" id="cb364-5" data-line-number="5">check b err x</a>
-<a class="sourceLine" id="cb364-6" data-line-number="6">  <span class="fu">|</span> b <span class="fu">=</span> pure x</a>
-<a class="sourceLine" id="cb364-7" data-line-number="7">  <span class="fu">|</span> otherwise <span class="fu">=</span> invalid err</a>
-<a class="sourceLine" id="cb364-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb364-9" data-line-number="9"><span class="ot">birthday ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb364-10" data-line-number="10">birthday name age <span class="fu">=</span> liftA2 congratulate checkedName checkedAge</a>
-<a class="sourceLine" id="cb364-11" data-line-number="11">  <span class="kw">where</span> checkedName <span class="fu">=</span> check (length name <span class="fu">&lt;</span> <span class="dv">10</span>) <span class="st">&quot;Name too long&quot;</span> name</a>
-<a class="sourceLine" id="cb364-12" data-line-number="12">        checkedAge <span class="fu">=</span> check (age <span class="fu">&lt;</span> <span class="dv">99</span>) <span class="st">&quot;Too old&quot;</span> age</a>
-<a class="sourceLine" id="cb364-13" data-line-number="13">        congratulate n a <span class="fu">=</span> <span class="st">&quot;Happy &quot;</span><span class="fu">++</span>show a<span class="fu">++</span><span class="st">&quot;th birthday &quot;</span><span class="fu">++</span>n<span class="fu">++</span><span class="st">&quot;!&quot;</span></a></code></pre></div>
-<div class="sourceCode" id="cb365"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb365-1" data-line-number="1">birthday <span class="st">&quot;Guy&quot;</span> <span class="dv">31</span></a>
-<a class="sourceLine" id="cb365-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> <span class="st">&quot;Happy 31th birthday Guy!&quot;</span></a>
-<a class="sourceLine" id="cb365-3" data-line-number="3">birthday <span class="st">&quot;Guybrush Threepwood&quot;</span> <span class="dv">31</span></a>
-<a class="sourceLine" id="cb365-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Name too long&quot;</span>]</a>
-<a class="sourceLine" id="cb365-5" data-line-number="5">birthday <span class="st">&quot;Yog-sothoth&quot;</span> <span class="dv">10000</span></a>
-<a class="sourceLine" id="cb365-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Name too long&quot;</span>,<span class="st">&quot;Too old&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb364"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb364-1" title="1"><span class="ot">invalid ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> a</a>
+<a class="sourceLine" id="cb364-2" title="2">invalid err <span class="fu">=</span> <span class="dt">Errors</span> [err]</a>
+<a class="sourceLine" id="cb364-3" title="3"></a>
+<a class="sourceLine" id="cb364-4" title="4"><span class="ot">check ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Validation</span> a</a>
+<a class="sourceLine" id="cb364-5" title="5">check b err x</a>
+<a class="sourceLine" id="cb364-6" title="6">  <span class="fu">|</span> b <span class="fu">=</span> <span class="fu">pure</span> x</a>
+<a class="sourceLine" id="cb364-7" title="7">  <span class="fu">|</span> <span class="fu">otherwise</span> <span class="fu">=</span> invalid err</a>
+<a class="sourceLine" id="cb364-8" title="8"></a>
+<a class="sourceLine" id="cb364-9" title="9"><span class="ot">birthday ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb364-10" title="10">birthday name age <span class="fu">=</span> liftA2 congratulate checkedName checkedAge</a>
+<a class="sourceLine" id="cb364-11" title="11">  <span class="kw">where</span> checkedName <span class="fu">=</span> check (<span class="fu">length</span> name <span class="fu">&lt;</span> <span class="dv">10</span>) <span class="st">&quot;Name too long&quot;</span> name</a>
+<a class="sourceLine" id="cb364-12" title="12">        checkedAge <span class="fu">=</span> check (age <span class="fu">&lt;</span> <span class="dv">99</span>) <span class="st">&quot;Too old&quot;</span> age</a>
+<a class="sourceLine" id="cb364-13" title="13">        congratulate n a <span class="fu">=</span> <span class="st">&quot;Happy &quot;</span><span class="fu">++show</span> a<span class="fu">++</span><span class="st">&quot;th birthday &quot;</span><span class="fu">++</span>n<span class="fu">++</span><span class="st">&quot;!&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb365"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb365-1" title="1">birthday <span class="st">&quot;Guy&quot;</span> <span class="dv">31</span></a>
+<a class="sourceLine" id="cb365-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> <span class="st">&quot;Happy 31th birthday Guy!&quot;</span></a>
+<a class="sourceLine" id="cb365-3" title="3">birthday <span class="st">&quot;Guybrush Threepwood&quot;</span> <span class="dv">31</span></a>
+<a class="sourceLine" id="cb365-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Name too long&quot;</span>]</a>
+<a class="sourceLine" id="cb365-5" title="5">birthday <span class="st">&quot;Yog-sothoth&quot;</span> <span class="dv">10000</span></a>
+<a class="sourceLine" id="cb365-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Name too long&quot;</span>,<span class="st">&quot;Too old&quot;</span>]</a></code></pre></div>
 <p>Oh right, here are the <code>Functor</code> and <code>Applicative</code> instances for <code>Validation</code>:</p>
-<div class="sourceCode" id="cb366"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb366-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb366-2" data-line-number="2">  fmap f (<span class="dt">Ok</span> x) <span class="fu">=</span> <span class="dt">Ok</span> (f x)</a>
-<a class="sourceLine" id="cb366-3" data-line-number="3">  fmap _ (<span class="dt">Errors</span> e) <span class="fu">=</span> <span class="dt">Errors</span> e</a>
-<a class="sourceLine" id="cb366-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb366-5" data-line-number="5"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb366-6" data-line-number="6">  pure x <span class="fu">=</span> <span class="dt">Ok</span> x</a>
-<a class="sourceLine" id="cb366-7" data-line-number="7">  liftA2 f (<span class="dt">Ok</span> x)      (<span class="dt">Ok</span> y)      <span class="fu">=</span> <span class="dt">Ok</span> (f x y)</a>
-<a class="sourceLine" id="cb366-8" data-line-number="8">  liftA2 f (<span class="dt">Errors</span> e1) (<span class="dt">Ok</span> y)      <span class="fu">=</span> <span class="dt">Errors</span> e1</a>
-<a class="sourceLine" id="cb366-9" data-line-number="9">  liftA2 f (<span class="dt">Ok</span> x)      (<span class="dt">Errors</span> e2) <span class="fu">=</span> <span class="dt">Errors</span> e2</a>
-<a class="sourceLine" id="cb366-10" data-line-number="10">  liftA2 f (<span class="dt">Errors</span> e1) (<span class="dt">Errors</span> e2) <span class="fu">=</span> <span class="dt">Errors</span> (e1<span class="fu">++</span>e2)</a></code></pre></div>
+<div class="sourceCode" id="cb366"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb366-1" title="1"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb366-2" title="2">  <span class="fu">fmap</span> f (<span class="dt">Ok</span> x) <span class="fu">=</span> <span class="dt">Ok</span> (f x)</a>
+<a class="sourceLine" id="cb366-3" title="3">  <span class="fu">fmap</span> _ (<span class="dt">Errors</span> e) <span class="fu">=</span> <span class="dt">Errors</span> e</a>
+<a class="sourceLine" id="cb366-4" title="4"></a>
+<a class="sourceLine" id="cb366-5" title="5"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb366-6" title="6">  <span class="fu">pure</span> x <span class="fu">=</span> <span class="dt">Ok</span> x</a>
+<a class="sourceLine" id="cb366-7" title="7">  liftA2 f (<span class="dt">Ok</span> x)      (<span class="dt">Ok</span> y)      <span class="fu">=</span> <span class="dt">Ok</span> (f x y)</a>
+<a class="sourceLine" id="cb366-8" title="8">  liftA2 f (<span class="dt">Errors</span> e1) (<span class="dt">Ok</span> y)      <span class="fu">=</span> <span class="dt">Errors</span> e1</a>
+<a class="sourceLine" id="cb366-9" title="9">  liftA2 f (<span class="dt">Ok</span> x)      (<span class="dt">Errors</span> e2) <span class="fu">=</span> <span class="dt">Errors</span> e2</a>
+<a class="sourceLine" id="cb366-10" title="10">  liftA2 f (<span class="dt">Errors</span> e1) (<span class="dt">Errors</span> e2) <span class="fu">=</span> <span class="dt">Errors</span> (e1<span class="fu">++</span>e2)</a></code></pre></div>
 <p>The definition of <code>liftA2</code> for <code>Validation</code> shows that the errors are collected together left-to-right. This can be seen in the example above where the expression <code>liftA2 congratulate checkedName checkedAge</code> outputs the error (<code>&quot;Name too long&quot;</code>) from <code>checkedName</code> first, and the error (<code>&quot;Too old&quot;</code>) from <code>checkedAge</code> last.</p>
 <!-- TODO other applicatives: IO, ? -->
 <h2 id="validating-lists-traverse"><span class="header-section-number">15.5</span> Validating Lists: <code>traverse</code></h2>
 <p>So far we’ve dealt with fixed-size things and Applicatives: we’ve applied a function of two or three arguments to some things. What if we have an arbitrary amount of inputs? What if we need to validate a list?</p>
 <p>Let’s look at some ways to implement a function like this:</p>
-<div class="sourceCode" id="cb367"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb367-1" data-line-number="1">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb367-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb367-3" data-line-number="3">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb367-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -4&quot;</span>]</a>
-<a class="sourceLine" id="cb367-5" data-line-number="5">allPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb367-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -2&quot;</span>,<span class="st">&quot;Not positive: -4&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb367"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb367-1" title="1">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb367-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb367-3" title="3">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb367-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -4&quot;</span>]</a>
+<a class="sourceLine" id="cb367-5" title="5">allPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb367-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -2&quot;</span>,<span class="st">&quot;Not positive: -4&quot;</span>]</a></code></pre></div>
 <p>As always, when working with lists, pattern matching and recursion are usually the way to go. Here’s a recursive solution:</p>
-<div class="sourceCode" id="cb368"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb368-1" data-line-number="1"><span class="ot">allPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Validation</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb368-2" data-line-number="2">allPositive [] <span class="fu">=</span> <span class="dt">Ok</span> []</a>
-<a class="sourceLine" id="cb368-3" data-line-number="3">allPositive (x<span class="fu">:</span>xs) <span class="fu">=</span> liftA2 (<span class="fu">:</span>) checkThis checkRest</a>
-<a class="sourceLine" id="cb368-4" data-line-number="4">  <span class="kw">where</span> checkThis <span class="fu">=</span> check (x<span class="fu">&gt;=</span><span class="dv">0</span>) (<span class="st">&quot;Not positive: &quot;</span><span class="fu">++</span>show x) x</a>
-<a class="sourceLine" id="cb368-5" data-line-number="5">        checkRest <span class="fu">=</span> allPositive xs</a></code></pre></div>
+<div class="sourceCode" id="cb368"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb368-1" title="1"><span class="ot">allPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Validation</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb368-2" title="2">allPositive [] <span class="fu">=</span> <span class="dt">Ok</span> []</a>
+<a class="sourceLine" id="cb368-3" title="3">allPositive (x<span class="fu">:</span>xs) <span class="fu">=</span> liftA2 (<span class="fu">:</span>) checkThis checkRest</a>
+<a class="sourceLine" id="cb368-4" title="4">  <span class="kw">where</span> checkThis <span class="fu">=</span> check (x<span class="fu">&gt;=</span><span class="dv">0</span>) (<span class="st">&quot;Not positive: &quot;</span><span class="fu">++show</span> x) x</a>
+<a class="sourceLine" id="cb368-5" title="5">        checkRest <span class="fu">=</span> allPositive xs</a></code></pre></div>
 <p>It’s a bit of a chore to always spell out a recursion like this. If we were working in a <code>Monad</code> we could just use a helper like <code>mapM</code>:</p>
-<div class="sourceCode" id="cb369"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb369-1" data-line-number="1">mapM (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb369-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb369-3" data-line-number="3">mapM (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb369-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb369"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb369-1" title="1"><span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb369-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb369-3" title="3"><span class="fu">mapM</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb369-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>The equivalent of <code>mapM</code> for <code>Applicative</code> is called <code>traverse</code>. It’s a member of the type class <code>Traversable</code>:</p>
-<div class="sourceCode" id="cb370"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb370-1" data-line-number="1">traverse<span class="ot"> ::</span> (<span class="dt">Traversable</span> t, <span class="dt">Applicative</span> f) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a></code></pre></div>
+<div class="sourceCode" id="cb370"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb370-1" title="1"><span class="fu">traverse</span><span class="ot"> ::</span> (<span class="dt">Traversable</span> t, <span class="dt">Applicative</span> f) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a></code></pre></div>
 <p>That’s one heck of a type signature, so let’s simplify it a bit. Lists are <code>Traversable</code>, so we can specialize this type into:</p>
-<div class="sourceCode" id="cb371"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb371-1" data-line-number="1">traverse<span class="ot"> ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> f [b]</a></code></pre></div>
+<div class="sourceCode" id="cb371"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb371-1" title="1"><span class="fu">traverse</span><span class="ot"> ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> f [b]</a></code></pre></div>
 <p>That looks like what we need! For Applicatives that are also Monads, <code>traverse</code> is just another name for <code>mapM</code>:</p>
-<div class="sourceCode" id="cb372"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb372-1" data-line-number="1">traverse (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb372-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb372-3" data-line-number="3">traverse (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb372-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb372"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb372-1" title="1"><span class="fu">traverse</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb372-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb372-3" title="3"><span class="fu">traverse</span> (\x <span class="ot">-&gt;</span> <span class="kw">if</span> x<span class="fu">&gt;=</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> x <span class="kw">else</span> <span class="dt">Nothing</span>) [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb372-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>But for our <code>Validation</code>, which isn’t a <code>Monad</code>, <code>traverse</code> is exactly what we want:</p>
-<div class="sourceCode" id="cb373"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb373-1" data-line-number="1"><span class="ot">allPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Validation</span> [<span class="dt">Int</span>]</a>
-<a class="sourceLine" id="cb373-2" data-line-number="2">allPositive xs <span class="fu">=</span> traverse checkNumber xs</a>
-<a class="sourceLine" id="cb373-3" data-line-number="3">  <span class="kw">where</span> checkNumber x <span class="fu">=</span> check (x<span class="fu">&gt;=</span><span class="dv">0</span>) (<span class="st">&quot;Not positive: &quot;</span><span class="fu">++</span>show x) x</a></code></pre></div>
-<div class="sourceCode" id="cb374"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb374-1" data-line-number="1">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb374-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
-<a class="sourceLine" id="cb374-3" data-line-number="3">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb374-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -4&quot;</span>]</a>
-<a class="sourceLine" id="cb374-5" data-line-number="5">allPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb374-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -2&quot;</span>,<span class="st">&quot;Not positive: -4&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb373"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb373-1" title="1"><span class="ot">allPositive ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Validation</span> [<span class="dt">Int</span>]</a>
+<a class="sourceLine" id="cb373-2" title="2">allPositive xs <span class="fu">=</span> <span class="fu">traverse</span> checkNumber xs</a>
+<a class="sourceLine" id="cb373-3" title="3">  <span class="kw">where</span> checkNumber x <span class="fu">=</span> check (x<span class="fu">&gt;=</span><span class="dv">0</span>) (<span class="st">&quot;Not positive: &quot;</span><span class="fu">++show</span> x) x</a></code></pre></div>
+<div class="sourceCode" id="cb374"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb374-1" title="1">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb374-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</a>
+<a class="sourceLine" id="cb374-3" title="3">allPositive [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb374-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -4&quot;</span>]</a>
+<a class="sourceLine" id="cb374-5" title="5">allPositive [<span class="dv">1</span>,<span class="fu">-</span><span class="dv">2</span>,<span class="dv">3</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb374-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not positive: -2&quot;</span>,<span class="st">&quot;Not positive: -4&quot;</span>]</a></code></pre></div>
 <p>Note how <code>traverse</code> for <code>Validation</code> collects all the errors together, in the order they occur in the original list.</p>
 <p>PS. In fact, <code>Validation</code> is one of the few examples of an <code>Applicative</code> that can’t be a <code>Monad</code>. Can you figure out why?</p>
 <!-- TODO `traverse_`? -->
 <h2 id="sidenote-traversable"><span class="header-section-number">15.6</span> Sidenote: <code>Traversable</code></h2>
 <p>So what things are <code>Traversable</code>? Many familiar structures. Here are some examples:</p>
-<div class="sourceCode" id="cb375"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb375-1" data-line-number="1"><span class="ot">decrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
-<a class="sourceLine" id="cb375-2" data-line-number="2">decrease i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> (i<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span></a></code></pre></div>
-<div class="sourceCode" id="cb376"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb376-1" data-line-number="1"><span class="co">-- Lists are Traversable</span></a>
-<a class="sourceLine" id="cb376-2" data-line-number="2">traverse decrease [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb376-3" data-line-number="3">traverse decrease [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb376-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb376-5" data-line-number="5"><span class="co">-- Arrays are Traversable</span></a>
-<a class="sourceLine" id="cb376-6" data-line-number="6">traverse decrease (array (<span class="dv">1</span>,<span class="dv">3</span>) [(<span class="dv">1</span>,<span class="dv">10</span>),(<span class="dv">2</span>,<span class="dv">11</span>),(<span class="dv">3</span>,<span class="dv">12</span>)])</a>
-<a class="sourceLine" id="cb376-7" data-line-number="7">         <span class="fu">==&gt;</span> <span class="dt">Just</span> (array (<span class="dv">1</span>,<span class="dv">3</span>) [(<span class="dv">1</span>,<span class="dv">9</span>),(<span class="dv">2</span>,<span class="dv">10</span>),(<span class="dv">3</span>,<span class="dv">11</span>)])</a>
-<a class="sourceLine" id="cb376-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb376-9" data-line-number="9"><span class="co">-- Maps are Traversable</span></a>
-<a class="sourceLine" id="cb376-10" data-line-number="10">traverse decrease (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">2</span>)])</a>
-<a class="sourceLine" id="cb376-11" data-line-number="11">         <span class="fu">==&gt;</span> <span class="dt">Just</span> (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">1</span>)])</a>
-<a class="sourceLine" id="cb376-12" data-line-number="12">traverse decrease (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">0</span>)])</a>
-<a class="sourceLine" id="cb376-13" data-line-number="13">         <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb376-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb376-15" data-line-number="15"><span class="co">-- Either is Traversable</span></a>
-<a class="sourceLine" id="cb376-16" data-line-number="16">traverse decrease (<span class="dt">Left</span> <span class="st">&quot;abc&quot;</span>) <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Left</span> <span class="st">&quot;abc&quot;</span>)</a>
-<a class="sourceLine" id="cb376-17" data-line-number="17">traverse decrease (<span class="dt">Right</span> <span class="dv">3</span>)    <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Right</span> <span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb376-18" data-line-number="18">traverse decrease (<span class="dt">Right</span> <span class="dv">0</span>)    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb375"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb375-1" title="1"><span class="ot">decrease ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Int</span></a>
+<a class="sourceLine" id="cb375-2" title="2">decrease i <span class="fu">=</span> <span class="kw">if</span> i<span class="fu">&gt;</span><span class="dv">0</span> <span class="kw">then</span> <span class="dt">Just</span> (i<span class="fu">-</span><span class="dv">1</span>) <span class="kw">else</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb376"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb376-1" title="1"><span class="co">-- Lists are Traversable</span></a>
+<a class="sourceLine" id="cb376-2" title="2"><span class="fu">traverse</span> decrease [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="dt">Just</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb376-3" title="3"><span class="fu">traverse</span> decrease [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">3</span>] <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb376-4" title="4"></a>
+<a class="sourceLine" id="cb376-5" title="5"><span class="co">-- Arrays are Traversable</span></a>
+<a class="sourceLine" id="cb376-6" title="6"><span class="fu">traverse</span> decrease (array (<span class="dv">1</span>,<span class="dv">3</span>) [(<span class="dv">1</span>,<span class="dv">10</span>),(<span class="dv">2</span>,<span class="dv">11</span>),(<span class="dv">3</span>,<span class="dv">12</span>)])</a>
+<a class="sourceLine" id="cb376-7" title="7">         <span class="fu">==&gt;</span> <span class="dt">Just</span> (array (<span class="dv">1</span>,<span class="dv">3</span>) [(<span class="dv">1</span>,<span class="dv">9</span>),(<span class="dv">2</span>,<span class="dv">10</span>),(<span class="dv">3</span>,<span class="dv">11</span>)])</a>
+<a class="sourceLine" id="cb376-8" title="8"></a>
+<a class="sourceLine" id="cb376-9" title="9"><span class="co">-- Maps are Traversable</span></a>
+<a class="sourceLine" id="cb376-10" title="10"><span class="fu">traverse</span> decrease (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">2</span>)])</a>
+<a class="sourceLine" id="cb376-11" title="11">         <span class="fu">==&gt;</span> <span class="dt">Just</span> (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">0</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">1</span>)])</a>
+<a class="sourceLine" id="cb376-12" title="12"><span class="fu">traverse</span> decrease (M.fromList [(<span class="st">&quot;a&quot;</span>,<span class="dv">1</span>),(<span class="st">&quot;b&quot;</span>,<span class="dv">0</span>)])</a>
+<a class="sourceLine" id="cb376-13" title="13">         <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb376-14" title="14"></a>
+<a class="sourceLine" id="cb376-15" title="15"><span class="co">-- Either is Traversable</span></a>
+<a class="sourceLine" id="cb376-16" title="16"><span class="fu">traverse</span> decrease (<span class="dt">Left</span> <span class="st">&quot;abc&quot;</span>) <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Left</span> <span class="st">&quot;abc&quot;</span>)</a>
+<a class="sourceLine" id="cb376-17" title="17"><span class="fu">traverse</span> decrease (<span class="dt">Right</span> <span class="dv">3</span>)    <span class="fu">==&gt;</span> <span class="dt">Just</span> (<span class="dt">Right</span> <span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb376-18" title="18"><span class="fu">traverse</span> decrease (<span class="dt">Right</span> <span class="dv">0</span>)    <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>So <code>Traversable</code> is a type class for all sorts of containers, kind of like <code>Foldable</code>. Indeed, if you look at the definition, <code>Traversable</code> is a subclass of <code>Foldable</code>. It also turns out that <code>traverse</code> and <code>mapM</code> are methods of the class!</p>
-<div class="sourceCode" id="cb377"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb377-1" data-line-number="1"><span class="kw">class</span> (<span class="dt">Functor</span> t, <span class="dt">Foldable</span> t) <span class="ot">=&gt;</span> <span class="dt">Traversable</span> t <span class="kw">where</span></a>
-<a class="sourceLine" id="cb377-2" data-line-number="2"><span class="ot">  traverse ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a>
-<a class="sourceLine" id="cb377-3" data-line-number="3"><span class="ot">  mapM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m (t b)</a></code></pre></div>
+<div class="sourceCode" id="cb377"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb377-1" title="1"><span class="kw">class</span> (<span class="dt">Functor</span> t, <span class="dt">Foldable</span> t) <span class="ot">=&gt;</span> <span class="dt">Traversable</span> t <span class="kw">where</span></a>
+<a class="sourceLine" id="cb377-2" title="2"><span class="ot">  traverse ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a>
+<a class="sourceLine" id="cb377-3" title="3"><span class="ot">  mapM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> m (t b)</a></code></pre></div>
 <p>It can be hard to keep the types straight here. Let’s go back to the type of <code>traverse</code>:</p>
-<div class="sourceCode" id="cb378"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb378-1" data-line-number="1">traverse<span class="ot"> ::</span> (<span class="dt">Traversable</span> t, <span class="dt">Applicative</span> f) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a></code></pre></div>
+<div class="sourceCode" id="cb378"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb378-1" title="1"><span class="fu">traverse</span><span class="ot"> ::</span> (<span class="dt">Traversable</span> t, <span class="dt">Applicative</span> f) <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> t a <span class="ot">-&gt;</span> f (t b)</a></code></pre></div>
 <p>Here we have two functors: <code>t</code> and <code>f</code>. The <code>t</code> functor is also a <code>Foldable</code> and a <code>Traversable</code> and the <code>f</code> functor is also an <code>Applicative</code>. The <code>traverse</code> function lets us run <code>f</code>-operations inside a <code>t</code>-container.</p>
 <p>Don’t worry if that feels abstract. In practice, you pretty much always use <code>traverse</code> on lists.</p>
 <h2 id="dealing-with-failure-alternative"><span class="header-section-number">15.7</span> Dealing with Failure: <code>Alternative</code></h2>
 <p>If you play around with applicatives a bit you’ll start to notice some limits to their power. For example, when writing parsers like we did in the <code>parseMoney</code> example, it would be nice to be able to try some a couple of different parsers and take any non-failure result. This is easy enough to write for a concrete Applicative like <code>Maybe</code>, as can be seen below.</p>
-<div class="sourceCode" id="cb379"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb379-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Answer</span> <span class="fu">=</span> <span class="dt">Yes</span> <span class="fu">|</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb379-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb379-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb379-4" data-line-number="4"><span class="ot">parseYes ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb379-5" data-line-number="5">parseYes <span class="st">&quot;y&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb379-6" data-line-number="6">parseYes <span class="st">&quot;yes&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb379-7" data-line-number="7">parseYes <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb379-8" data-line-number="8">parseYes _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb379-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb379-10" data-line-number="10"><span class="ot">parseNo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb379-11" data-line-number="11">parseNo <span class="st">&quot;n&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb379-12" data-line-number="12">parseNo <span class="st">&quot;no&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb379-13" data-line-number="13">parseNo <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb379-14" data-line-number="14">parseNo _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb379-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb379-16" data-line-number="16"><span class="ot">eitherOf ::</span> <span class="dt">Maybe</span> x <span class="ot">-&gt;</span> <span class="dt">Maybe</span> x <span class="ot">-&gt;</span> <span class="dt">Maybe</span> x</a>
-<a class="sourceLine" id="cb379-17" data-line-number="17">eitherOf (<span class="dt">Just</span> x) _  <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb379-18" data-line-number="18">eitherOf <span class="dt">Nothing</span>  mx <span class="fu">=</span> mx</a>
-<a class="sourceLine" id="cb379-19" data-line-number="19"></a>
-<a class="sourceLine" id="cb379-20" data-line-number="20"><span class="ot">parseAnswer ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb379-21" data-line-number="21"><span class="co">-- prefer positive answers!</span></a>
-<a class="sourceLine" id="cb379-22" data-line-number="22">parseAnswer s <span class="fu">=</span> eitherOf (parseYes s) (parseNo s)</a></code></pre></div>
-<div class="sourceCode" id="cb380"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb380-1" data-line-number="1">parseAnswer <span class="st">&quot;yes&quot;</span>    <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb380-2" data-line-number="2">parseAnswer <span class="st">&quot;y&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb380-3" data-line-number="3">parseAnswer <span class="st">&quot;n&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb380-4" data-line-number="4">parseAnswer <span class="st">&quot;maybe&quot;</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb380-5" data-line-number="5">parseAnswer <span class="st">&quot;x&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
+<div class="sourceCode" id="cb379"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb379-1" title="1"><span class="kw">data</span> <span class="dt">Answer</span> <span class="fu">=</span> <span class="dt">Yes</span> <span class="fu">|</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb379-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb379-3" title="3"></a>
+<a class="sourceLine" id="cb379-4" title="4"><span class="ot">parseYes ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb379-5" title="5">parseYes <span class="st">&quot;y&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb379-6" title="6">parseYes <span class="st">&quot;yes&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb379-7" title="7">parseYes <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb379-8" title="8">parseYes _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb379-9" title="9"></a>
+<a class="sourceLine" id="cb379-10" title="10"><span class="ot">parseNo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb379-11" title="11">parseNo <span class="st">&quot;n&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb379-12" title="12">parseNo <span class="st">&quot;no&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb379-13" title="13">parseNo <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="dt">Just</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb379-14" title="14">parseNo _ <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb379-15" title="15"></a>
+<a class="sourceLine" id="cb379-16" title="16"><span class="ot">eitherOf ::</span> <span class="dt">Maybe</span> x <span class="ot">-&gt;</span> <span class="dt">Maybe</span> x <span class="ot">-&gt;</span> <span class="dt">Maybe</span> x</a>
+<a class="sourceLine" id="cb379-17" title="17">eitherOf (<span class="dt">Just</span> x) _  <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb379-18" title="18">eitherOf <span class="dt">Nothing</span>  mx <span class="fu">=</span> mx</a>
+<a class="sourceLine" id="cb379-19" title="19"></a>
+<a class="sourceLine" id="cb379-20" title="20"><span class="ot">parseAnswer ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb379-21" title="21"><span class="co">-- prefer positive answers!</span></a>
+<a class="sourceLine" id="cb379-22" title="22">parseAnswer s <span class="fu">=</span> eitherOf (parseYes s) (parseNo s)</a></code></pre></div>
+<div class="sourceCode" id="cb380"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb380-1" title="1">parseAnswer <span class="st">&quot;yes&quot;</span>    <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb380-2" title="2">parseAnswer <span class="st">&quot;y&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb380-3" title="3">parseAnswer <span class="st">&quot;n&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb380-4" title="4">parseAnswer <span class="st">&quot;maybe&quot;</span>  <span class="fu">==&gt;</span> <span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb380-5" title="5">parseAnswer <span class="st">&quot;x&quot;</span>      <span class="fu">==&gt;</span> <span class="dt">Nothing</span></a></code></pre></div>
 <p>How could we generalize <code>eitherOf</code>? We can’t give it the type <code>Applicative f =&gt; f x -&gt; f x -&gt; f x</code> because then the implementation would need to be effectively something like <code>eitherOf a b = liftA2 something a b</code>, but then <code>eitherOf Nothing (Just x)</code> would be <code>Nothing</code> (since that’s how the Applicative instance works)!</p>
 <p>It turns out we need a new type class: <code>Alternative</code>. An Alternative adds two operations to Applicative: <code>empty</code> means no results, and <code>&lt;|&gt;</code> means combining results.</p>
-<div class="sourceCode" id="cb381"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb381-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> <span class="dt">Alternative</span> f <span class="kw">where</span></a>
-<a class="sourceLine" id="cb381-2" data-line-number="2"><span class="ot">  empty ::</span> f a</a>
-<a class="sourceLine" id="cb381-3" data-line-number="3"><span class="ot">  (&lt;|&gt;) ::</span> f a <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f a</a>
-<a class="sourceLine" id="cb381-4" data-line-number="4">  <span class="co">-- some other operations omitted</span></a></code></pre></div>
+<div class="sourceCode" id="cb381"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb381-1" title="1"><span class="kw">class</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> <span class="dt">Alternative</span> f <span class="kw">where</span></a>
+<a class="sourceLine" id="cb381-2" title="2"><span class="ot">  empty ::</span> f a</a>
+<a class="sourceLine" id="cb381-3" title="3"><span class="ot">  (&lt;|&gt;) ::</span> f a <span class="ot">-&gt;</span> f a <span class="ot">-&gt;</span> f a</a>
+<a class="sourceLine" id="cb381-4" title="4">  <span class="co">-- some other operations omitted</span></a></code></pre></div>
 <p>Now we can rewrite our parsing code using general operations:</p>
-<div class="sourceCode" id="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb382-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Answer</span> <span class="fu">=</span> <span class="dt">Yes</span> <span class="fu">|</span> <span class="dt">No</span></a>
-<a class="sourceLine" id="cb382-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb382-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb382-4" data-line-number="4"><span class="ot">parseYes ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb382-5" data-line-number="5">parseYes <span class="st">&quot;y&quot;</span> <span class="fu">=</span> pure <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb382-6" data-line-number="6">parseYes <span class="st">&quot;yes&quot;</span> <span class="fu">=</span> pure <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb382-7" data-line-number="7">parseYes <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> pure <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb382-8" data-line-number="8">parseYes _ <span class="fu">=</span> empty</a>
-<a class="sourceLine" id="cb382-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb382-10" data-line-number="10"><span class="ot">parseNo ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb382-11" data-line-number="11">parseNo <span class="st">&quot;n&quot;</span> <span class="fu">=</span> pure <span class="dt">No</span></a>
-<a class="sourceLine" id="cb382-12" data-line-number="12">parseNo <span class="st">&quot;no&quot;</span> <span class="fu">=</span> pure <span class="dt">No</span></a>
-<a class="sourceLine" id="cb382-13" data-line-number="13">parseNo <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> pure <span class="dt">No</span></a>
-<a class="sourceLine" id="cb382-14" data-line-number="14">parseNo _ <span class="fu">=</span> empty</a>
-<a class="sourceLine" id="cb382-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb382-16" data-line-number="16"><span class="ot">parseAnswer ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb382-17" data-line-number="17">parseAnswer s <span class="fu">=</span> parseYes s <span class="fu">&lt;|&gt;</span> parseNo s</a></code></pre></div>
+<div class="sourceCode" id="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb382-1" title="1"><span class="kw">data</span> <span class="dt">Answer</span> <span class="fu">=</span> <span class="dt">Yes</span> <span class="fu">|</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb382-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb382-3" title="3"></a>
+<a class="sourceLine" id="cb382-4" title="4"><span class="ot">parseYes ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb382-5" title="5">parseYes <span class="st">&quot;y&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb382-6" title="6">parseYes <span class="st">&quot;yes&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb382-7" title="7">parseYes <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb382-8" title="8">parseYes _ <span class="fu">=</span> empty</a>
+<a class="sourceLine" id="cb382-9" title="9"></a>
+<a class="sourceLine" id="cb382-10" title="10"><span class="ot">parseNo ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb382-11" title="11">parseNo <span class="st">&quot;n&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb382-12" title="12">parseNo <span class="st">&quot;no&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb382-13" title="13">parseNo <span class="st">&quot;maybe&quot;</span> <span class="fu">=</span> <span class="fu">pure</span> <span class="dt">No</span></a>
+<a class="sourceLine" id="cb382-14" title="14">parseNo _ <span class="fu">=</span> empty</a>
+<a class="sourceLine" id="cb382-15" title="15"></a>
+<a class="sourceLine" id="cb382-16" title="16"><span class="ot">parseAnswer ::</span> <span class="dt">Alternative</span> f <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> f <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb382-17" title="17">parseAnswer s <span class="fu">=</span> parseYes s <span class="fu">&lt;|&gt;</span> parseNo s</a></code></pre></div>
 <p>We can also pick which <code>Alternative</code> we run our parser in to get different behaviours. <code>Maybe</code> gives us only one result, while <code>[]</code> gives us all possible results.</p>
-<div class="sourceCode" id="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb383-1" data-line-number="1"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;yes&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb383-2" data-line-number="2"><span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb383-3" data-line-number="3"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;maybe&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
-<a class="sourceLine" id="cb383-4" data-line-number="4"><span class="dt">Just</span> <span class="dt">Yes</span></a>
-<a class="sourceLine" id="cb383-5" data-line-number="5"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;yes&quot;</span><span class="ot"> ::</span> [<span class="dt">Answer</span>]</a>
-<a class="sourceLine" id="cb383-6" data-line-number="6">[<span class="dt">Yes</span>]</a>
-<a class="sourceLine" id="cb383-7" data-line-number="7"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;maybe&quot;</span><span class="ot"> ::</span> [<span class="dt">Answer</span>]</a>
-<a class="sourceLine" id="cb383-8" data-line-number="8">[<span class="dt">Yes</span>,<span class="dt">No</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb383-1" title="1"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;yes&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb383-2" title="2"><span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb383-3" title="3"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;maybe&quot;</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Answer</span></a>
+<a class="sourceLine" id="cb383-4" title="4"><span class="dt">Just</span> <span class="dt">Yes</span></a>
+<a class="sourceLine" id="cb383-5" title="5"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;yes&quot;</span><span class="ot"> ::</span> [<span class="dt">Answer</span>]</a>
+<a class="sourceLine" id="cb383-6" title="6">[<span class="dt">Yes</span>]</a>
+<a class="sourceLine" id="cb383-7" title="7"><span class="fu">&gt;</span> parseAnswer <span class="st">&quot;maybe&quot;</span><span class="ot"> ::</span> [<span class="dt">Answer</span>]</a>
+<a class="sourceLine" id="cb383-8" title="8">[<span class="dt">Yes</span>,<span class="dt">No</span>]</a></code></pre></div>
 <p>The <code>Alternative</code> instances for <code>[]</code> and <code>Maybe</code> are unsurprising:</p>
-<div class="sourceCode" id="cb384"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb384-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Alternative</span> [] <span class="kw">where</span></a>
-<a class="sourceLine" id="cb384-2" data-line-number="2">  empty <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb384-3" data-line-number="3">  (<span class="fu">&lt;|&gt;</span>) <span class="fu">=</span> (<span class="fu">++</span>)</a>
-<a class="sourceLine" id="cb384-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb384-5" data-line-number="5"><span class="kw">instance</span> <span class="dt">Alternative</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb384-6" data-line-number="6">  empty <span class="fu">=</span> <span class="dt">Nothing</span></a>
-<a class="sourceLine" id="cb384-7" data-line-number="7">  <span class="dt">Just</span> x  <span class="fu">&lt;|&gt;</span> _  <span class="fu">=</span> <span class="dt">Just</span> x</a>
-<a class="sourceLine" id="cb384-8" data-line-number="8">  <span class="dt">Nothing</span> <span class="fu">&lt;|&gt;</span> mx <span class="fu">=</span> mx</a></code></pre></div>
+<div class="sourceCode" id="cb384"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb384-1" title="1"><span class="kw">instance</span> <span class="dt">Alternative</span> [] <span class="kw">where</span></a>
+<a class="sourceLine" id="cb384-2" title="2">  empty <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb384-3" title="3">  (<span class="fu">&lt;|&gt;</span>) <span class="fu">=</span> (<span class="fu">++</span>)</a>
+<a class="sourceLine" id="cb384-4" title="4"></a>
+<a class="sourceLine" id="cb384-5" title="5"><span class="kw">instance</span> <span class="dt">Alternative</span> <span class="dt">Maybe</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb384-6" title="6">  empty <span class="fu">=</span> <span class="dt">Nothing</span></a>
+<a class="sourceLine" id="cb384-7" title="7">  <span class="dt">Just</span> x  <span class="fu">&lt;|&gt;</span> _  <span class="fu">=</span> <span class="dt">Just</span> x</a>
+<a class="sourceLine" id="cb384-8" title="8">  <span class="dt">Nothing</span> <span class="fu">&lt;|&gt;</span> mx <span class="fu">=</span> mx</a></code></pre></div>
 <p>The <code>Validation</code> type is also an <code>Alternative</code>. The instance collects together all error messages, just like the <code>Applicative</code> instance did.</p>
-<div class="sourceCode" id="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb385-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Alternative</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb385-2" data-line-number="2">  empty <span class="fu">=</span> <span class="dt">Errors</span> []</a>
-<a class="sourceLine" id="cb385-3" data-line-number="3">  <span class="dt">Ok</span> x <span class="fu">&lt;|&gt;</span> _ <span class="fu">=</span> <span class="dt">Ok</span> x</a>
-<a class="sourceLine" id="cb385-4" data-line-number="4">  <span class="dt">Errors</span> e1 <span class="fu">&lt;|&gt;</span> <span class="dt">Ok</span> y <span class="fu">=</span> <span class="dt">Ok</span> y</a>
-<a class="sourceLine" id="cb385-5" data-line-number="5">  <span class="dt">Errors</span> e1 <span class="fu">&lt;|&gt;</span> <span class="dt">Errors</span> e2 <span class="fu">=</span> <span class="dt">Errors</span> (e1<span class="fu">++</span>e2)</a></code></pre></div>
+<div class="sourceCode" id="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb385-1" title="1"><span class="kw">instance</span> <span class="dt">Alternative</span> <span class="dt">Validation</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb385-2" title="2">  empty <span class="fu">=</span> <span class="dt">Errors</span> []</a>
+<a class="sourceLine" id="cb385-3" title="3">  <span class="dt">Ok</span> x <span class="fu">&lt;|&gt;</span> _ <span class="fu">=</span> <span class="dt">Ok</span> x</a>
+<a class="sourceLine" id="cb385-4" title="4">  <span class="dt">Errors</span> e1 <span class="fu">&lt;|&gt;</span> <span class="dt">Ok</span> y <span class="fu">=</span> <span class="dt">Ok</span> y</a>
+<a class="sourceLine" id="cb385-5" title="5">  <span class="dt">Errors</span> e1 <span class="fu">&lt;|&gt;</span> <span class="dt">Errors</span> e2 <span class="fu">=</span> <span class="dt">Errors</span> (e1<span class="fu">++</span>e2)</a></code></pre></div>
 <p>Here’s a final example: validating contact information, which is either a phone number or an email address.</p>
-<div class="sourceCode" id="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb386-1" data-line-number="1"><span class="kw">data</span> <span class="dt">ContactInfo</span> <span class="fu">=</span> <span class="dt">Email</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Phone</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb386-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb386-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb386-4" data-line-number="4"><span class="ot">validateEmail ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
-<a class="sourceLine" id="cb386-5" data-line-number="5">validateEmail s <span class="fu">=</span> check (elem <span class="ch">&#39;@&#39;</span> s) <span class="st">&quot;Not an email: should contain a @&quot;</span> (<span class="dt">Email</span> s)</a>
-<a class="sourceLine" id="cb386-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb386-7" data-line-number="7"><span class="ot">checkLength ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
-<a class="sourceLine" id="cb386-8" data-line-number="8">checkLength s <span class="fu">=</span> check (length s <span class="fu">&lt;=</span> <span class="dv">10</span>) <span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span> (<span class="dt">Phone</span> s)</a>
-<a class="sourceLine" id="cb386-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb386-10" data-line-number="10"><span class="ot">checkDigits ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
-<a class="sourceLine" id="cb386-11" data-line-number="11">checkDigits s <span class="fu">=</span> check (all isDigit s) <span class="st">&quot;Not a phone number: should be all numbers&quot;</span> (<span class="dt">Phone</span> s)</a>
-<a class="sourceLine" id="cb386-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb386-13" data-line-number="13"><span class="ot">validatePhone ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
-<a class="sourceLine" id="cb386-14" data-line-number="14">validatePhone s <span class="fu">=</span> checkDigits s <span class="fu">*&gt;</span> checkLength s</a>
-<a class="sourceLine" id="cb386-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb386-16" data-line-number="16"><span class="ot">validateContactInfo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
-<a class="sourceLine" id="cb386-17" data-line-number="17">validateContactInfo s <span class="fu">=</span> validateEmail s <span class="fu">&lt;|&gt;</span> validatePhone s</a></code></pre></div>
-<div class="sourceCode" id="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb387-1" data-line-number="1">validateContactInfo <span class="st">&quot;user@example.com&quot;</span></a>
-<a class="sourceLine" id="cb387-2" data-line-number="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> (<span class="dt">Email</span> <span class="st">&quot;user@example.com&quot;</span>)</a>
-<a class="sourceLine" id="cb387-3" data-line-number="3">validateContactInfo <span class="st">&quot;01234&quot;</span></a>
-<a class="sourceLine" id="cb387-4" data-line-number="4">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> (<span class="dt">Phone</span> <span class="st">&quot;01234&quot;</span>)</a>
-<a class="sourceLine" id="cb387-5" data-line-number="5">validateContactInfo <span class="st">&quot;01234567890&quot;</span></a>
-<a class="sourceLine" id="cb387-6" data-line-number="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,<span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span>]</a>
-<a class="sourceLine" id="cb387-7" data-line-number="7">validateContactInfo <span class="st">&quot;01234567890x&quot;</span></a>
-<a class="sourceLine" id="cb387-8" data-line-number="8">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,</a>
-<a class="sourceLine" id="cb387-9" data-line-number="9">              <span class="st">&quot;Not a phone number: should be all numbers&quot;</span>,</a>
-<a class="sourceLine" id="cb387-10" data-line-number="10">              <span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span>]</a>
-<a class="sourceLine" id="cb387-11" data-line-number="11">validateContactInfo <span class="st">&quot;x&quot;</span></a>
-<a class="sourceLine" id="cb387-12" data-line-number="12">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,</a>
-<a class="sourceLine" id="cb387-13" data-line-number="13">              <span class="st">&quot;Not a phone number: should be all numbers&quot;</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb386-1" title="1"><span class="kw">data</span> <span class="dt">ContactInfo</span> <span class="fu">=</span> <span class="dt">Email</span> <span class="dt">String</span> <span class="fu">|</span> <span class="dt">Phone</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb386-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb386-3" title="3"></a>
+<a class="sourceLine" id="cb386-4" title="4"><span class="ot">validateEmail ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
+<a class="sourceLine" id="cb386-5" title="5">validateEmail s <span class="fu">=</span> check (<span class="fu">elem</span> <span class="ch">&#39;@&#39;</span> s) <span class="st">&quot;Not an email: should contain a @&quot;</span> (<span class="dt">Email</span> s)</a>
+<a class="sourceLine" id="cb386-6" title="6"></a>
+<a class="sourceLine" id="cb386-7" title="7"><span class="ot">checkLength ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
+<a class="sourceLine" id="cb386-8" title="8">checkLength s <span class="fu">=</span> check (<span class="fu">length</span> s <span class="fu">&lt;=</span> <span class="dv">10</span>) <span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span> (<span class="dt">Phone</span> s)</a>
+<a class="sourceLine" id="cb386-9" title="9"></a>
+<a class="sourceLine" id="cb386-10" title="10"><span class="ot">checkDigits ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
+<a class="sourceLine" id="cb386-11" title="11">checkDigits s <span class="fu">=</span> check (<span class="fu">all</span> <span class="fu">isDigit</span> s) <span class="st">&quot;Not a phone number: should be all numbers&quot;</span> (<span class="dt">Phone</span> s)</a>
+<a class="sourceLine" id="cb386-12" title="12"></a>
+<a class="sourceLine" id="cb386-13" title="13"><span class="ot">validatePhone ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
+<a class="sourceLine" id="cb386-14" title="14">validatePhone s <span class="fu">=</span> checkDigits s <span class="fu">*&gt;</span> checkLength s</a>
+<a class="sourceLine" id="cb386-15" title="15"></a>
+<a class="sourceLine" id="cb386-16" title="16"><span class="ot">validateContactInfo ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Validation</span> <span class="dt">ContactInfo</span></a>
+<a class="sourceLine" id="cb386-17" title="17">validateContactInfo s <span class="fu">=</span> validateEmail s <span class="fu">&lt;|&gt;</span> validatePhone s</a></code></pre></div>
+<div class="sourceCode" id="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb387-1" title="1">validateContactInfo <span class="st">&quot;user@example.com&quot;</span></a>
+<a class="sourceLine" id="cb387-2" title="2">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> (<span class="dt">Email</span> <span class="st">&quot;user@example.com&quot;</span>)</a>
+<a class="sourceLine" id="cb387-3" title="3">validateContactInfo <span class="st">&quot;01234&quot;</span></a>
+<a class="sourceLine" id="cb387-4" title="4">  <span class="fu">==&gt;</span> <span class="dt">Ok</span> (<span class="dt">Phone</span> <span class="st">&quot;01234&quot;</span>)</a>
+<a class="sourceLine" id="cb387-5" title="5">validateContactInfo <span class="st">&quot;01234567890&quot;</span></a>
+<a class="sourceLine" id="cb387-6" title="6">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,<span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span>]</a>
+<a class="sourceLine" id="cb387-7" title="7">validateContactInfo <span class="st">&quot;01234567890x&quot;</span></a>
+<a class="sourceLine" id="cb387-8" title="8">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,</a>
+<a class="sourceLine" id="cb387-9" title="9">              <span class="st">&quot;Not a phone number: should be all numbers&quot;</span>,</a>
+<a class="sourceLine" id="cb387-10" title="10">              <span class="st">&quot;Not a phone number: should be at most 10 digits&quot;</span>]</a>
+<a class="sourceLine" id="cb387-11" title="11">validateContactInfo <span class="st">&quot;x&quot;</span></a>
+<a class="sourceLine" id="cb387-12" title="12">  <span class="fu">==&gt;</span> <span class="dt">Errors</span> [<span class="st">&quot;Not an email: should contain a @&quot;</span>,</a>
+<a class="sourceLine" id="cb387-13" title="13">              <span class="st">&quot;Not a phone number: should be all numbers&quot;</span>]</a></code></pre></div>
 <p>Note how here, just like in previous examples, the errors are collected left-to-right: the errors from <code>validateEmail</code> come before the errors from <code>validatePhone</code>. The error from <code>checkDigits</code> comes before the error from <code>checkLength</code>.</p>
 <!--
 TODO compare to `Monoid`?
@@ -4160,38 +4158,38 @@ TODO explain `some` and `many`
 <p>There are multiple parser libraries that use Applicatives. For example, <a href="https://hackage.haskell.org/package/regex-applicative">regex-applicative</a>, <a href="https://hackage.haskell.org/package/optparse-applicative">optparse-applicative</a>, <a href="https://cs-syd.eu/posts/2020-06-28-yamlparse-applicative">yamlparse-applicative</a>, <a href="https://hackage.haskell.org/package/json-stream">json-stream</a>, and so on.</p>
 <h3 id="monads-and-applicatives"><span class="header-section-number">15.8.3</span> Monads and Applicatives</h3>
 <p>So what’s the relationship between an Monad and an Applicative? If an Applicative is also a Monad, the following laws hold:</p>
-<div class="sourceCode" id="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb388-1" data-line-number="1">pure             <span class="fu">===</span> return</a>
-<a class="sourceLine" id="cb388-2" data-line-number="2"></a>
-<a class="sourceLine" id="cb388-3" data-line-number="3">fmap             <span class="fu">===</span> liftM</a>
-<a class="sourceLine" id="cb388-4" data-line-number="4"></a>
-<a class="sourceLine" id="cb388-5" data-line-number="5">fmap f op        <span class="fu">===</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op</a>
-<a class="sourceLine" id="cb388-6" data-line-number="6">                        return (f x)</a>
-<a class="sourceLine" id="cb388-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb388-8" data-line-number="8">liftA2           <span class="fu">===</span> liftM2</a>
-<a class="sourceLine" id="cb388-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb388-10" data-line-number="10">liftA2 f op1 op2 <span class="fu">===</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op1</a>
-<a class="sourceLine" id="cb388-11" data-line-number="11">                        y <span class="ot">&lt;-</span> op2</a>
-<a class="sourceLine" id="cb388-12" data-line-number="12">                        return (f x y)</a>
-<a class="sourceLine" id="cb388-13" data-line-number="13"></a>
-<a class="sourceLine" id="cb388-14" data-line-number="14">op1 <span class="fu">*&gt;</span> op2       <span class="fu">===</span> op1 <span class="fu">&gt;&gt;</span> op2</a>
-<a class="sourceLine" id="cb388-15" data-line-number="15"></a>
-<a class="sourceLine" id="cb388-16" data-line-number="16">op1 <span class="fu">&lt;*&gt;</span> op2      <span class="fu">===</span> <span class="kw">do</span> f <span class="ot">&lt;-</span> op1</a>
-<a class="sourceLine" id="cb388-17" data-line-number="17">                        x <span class="ot">&lt;-</span> op2</a>
-<a class="sourceLine" id="cb388-18" data-line-number="18">                        return (f x)</a></code></pre></div>
+<div class="sourceCode" id="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb388-1" title="1"><span class="fu">pure</span>             <span class="fu">===</span> <span class="fu">return</span></a>
+<a class="sourceLine" id="cb388-2" title="2"></a>
+<a class="sourceLine" id="cb388-3" title="3"><span class="fu">fmap</span>             <span class="fu">===</span> liftM</a>
+<a class="sourceLine" id="cb388-4" title="4"></a>
+<a class="sourceLine" id="cb388-5" title="5"><span class="fu">fmap</span> f op        <span class="fu">===</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op</a>
+<a class="sourceLine" id="cb388-6" title="6">                        <span class="fu">return</span> (f x)</a>
+<a class="sourceLine" id="cb388-7" title="7"></a>
+<a class="sourceLine" id="cb388-8" title="8">liftA2           <span class="fu">===</span> liftM2</a>
+<a class="sourceLine" id="cb388-9" title="9"></a>
+<a class="sourceLine" id="cb388-10" title="10">liftA2 f op1 op2 <span class="fu">===</span> <span class="kw">do</span> x <span class="ot">&lt;-</span> op1</a>
+<a class="sourceLine" id="cb388-11" title="11">                        y <span class="ot">&lt;-</span> op2</a>
+<a class="sourceLine" id="cb388-12" title="12">                        <span class="fu">return</span> (f x y)</a>
+<a class="sourceLine" id="cb388-13" title="13"></a>
+<a class="sourceLine" id="cb388-14" title="14">op1 <span class="fu">*&gt;</span> op2       <span class="fu">===</span> op1 <span class="fu">&gt;&gt;</span> op2</a>
+<a class="sourceLine" id="cb388-15" title="15"></a>
+<a class="sourceLine" id="cb388-16" title="16">op1 <span class="fu">&lt;*&gt;</span> op2      <span class="fu">===</span> <span class="kw">do</span> f <span class="ot">&lt;-</span> op1</a>
+<a class="sourceLine" id="cb388-17" title="17">                        x <span class="ot">&lt;-</span> op2</a>
+<a class="sourceLine" id="cb388-18" title="18">                        <span class="fu">return</span> (f x)</a></code></pre></div>
 <p>When working in a <code>Monad</code>, you can freely mix <code>Applicative</code> and <code>Functor</code> with <code>Monad</code> operations. As an example, let’s rewrite <code>mapM</code> until it only uses applicative operations, and thus get an implementation for <code>traverse</code>. This is our starting point:</p>
-<div class="sourceCode" id="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb389-1" data-line-number="1">myMapM op [] <span class="fu">=</span> return []</a>
-<a class="sourceLine" id="cb389-2" data-line-number="2">myMapM op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> op x</a>
-<a class="sourceLine" id="cb389-3" data-line-number="3">                      ys <span class="ot">&lt;-</span> myMapM op xs</a>
-<a class="sourceLine" id="cb389-4" data-line-number="4">                      return (y<span class="fu">:</span>ys)</a></code></pre></div>
+<div class="sourceCode" id="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb389-1" title="1">myMapM op [] <span class="fu">=</span> <span class="fu">return</span> []</a>
+<a class="sourceLine" id="cb389-2" title="2">myMapM op (x<span class="fu">:</span>xs) <span class="fu">=</span> <span class="kw">do</span> y <span class="ot">&lt;-</span> op x</a>
+<a class="sourceLine" id="cb389-3" title="3">                      ys <span class="ot">&lt;-</span> myMapM op xs</a>
+<a class="sourceLine" id="cb389-4" title="4">                      <span class="fu">return</span> (y<span class="fu">:</span>ys)</a></code></pre></div>
 <p>GHCi tells us it only works for Monads:</p>
-<div class="sourceCode" id="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb390-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t myMapM</a>
-<a class="sourceLine" id="cb390-2" data-line-number="2"><span class="ot">myMapM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m [b]</a></code></pre></div>
+<div class="sourceCode" id="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb390-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t myMapM</a>
+<a class="sourceLine" id="cb390-2" title="2"><span class="ot">myMapM ::</span> <span class="dt">Monad</span> m <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> m b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> m [b]</a></code></pre></div>
 <p>Let’s apply the <code>pure === return</code> and the <code>liftA2</code> laws from above:</p>
-<div class="sourceCode" id="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb391-1" data-line-number="1">myMapM op [] <span class="fu">=</span> pure []</a>
-<a class="sourceLine" id="cb391-2" data-line-number="2">myMapM op (x<span class="fu">:</span>xs) <span class="fu">=</span> liftA2 (<span class="fu">:</span>) (op x) (myMapM op xs)</a></code></pre></div>
+<div class="sourceCode" id="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb391-1" title="1">myMapM op [] <span class="fu">=</span> <span class="fu">pure</span> []</a>
+<a class="sourceLine" id="cb391-2" title="2">myMapM op (x<span class="fu">:</span>xs) <span class="fu">=</span> liftA2 (<span class="fu">:</span>) (op x) (myMapM op xs)</a></code></pre></div>
 <p>Ta-da! Now <code>myMapM</code> works for any <code>Applicative</code>:</p>
-<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb392-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t myMapM</a>
-<a class="sourceLine" id="cb392-2" data-line-number="2"><span class="ot">myMapM ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> f [b]</a></code></pre></div>
+<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb392-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>t myMapM</a>
+<a class="sourceLine" id="cb392-2" title="2"><span class="ot">myMapM ::</span> <span class="dt">Applicative</span> f <span class="ot">=&gt;</span> (a <span class="ot">-&gt;</span> f b) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> f [b]</a></code></pre></div>
 <h2 id="quiz-5"><span class="header-section-number">15.9</span> Quiz</h2>
 <p>What’s the type of <code>x</code> in <code>liftA2 (&amp;&amp;) Nothing x</code>?</p>
 <ol class="quiz">
@@ -4269,369 +4267,369 @@ TODO explain `some` and `many`
 <h2 id="testing-with-quickcheck"><span class="header-section-number">16.1</span> Testing with QuickCheck</h2>
 <p>One of the benefits of purity is that pure functions are easy to test: you don’t need to set up any global state, you can just pass in arguments and check that the result is ok. In this section, we’ll take a quick tour of the <em>property-based testing</em> library QuickCheck, which has also been used for checking that your answers to exercises are right on this course!</p>
 <p>Let’s look at testing a (faulty) implementation of <code>reverse</code>. You can find this and the following examples in the file <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/QuickCheck.hs"><code>exercises/Examples/QuickCheck.hs</code></a>.</p>
-<div class="sourceCode" id="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb393-1" data-line-number="1"><span class="ot">rev ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
-<a class="sourceLine" id="cb393-2" data-line-number="2">rev [] <span class="fu">=</span> []</a>
-<a class="sourceLine" id="cb393-3" data-line-number="3">rev (x<span class="fu">:</span>xs) <span class="fu">=</span> xs <span class="fu">++</span> [x]</a></code></pre></div>
+<div class="sourceCode" id="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb393-1" title="1"><span class="ot">rev ::</span> [a] <span class="ot">-&gt;</span> [a]</a>
+<a class="sourceLine" id="cb393-2" title="2">rev [] <span class="fu">=</span> []</a>
+<a class="sourceLine" id="cb393-3" title="3">rev (x<span class="fu">:</span>xs) <span class="fu">=</span> xs <span class="fu">++</span> [x]</a></code></pre></div>
 <p>We can write an individual test case using the <code>===</code> operator from QuickCheck:</p>
-<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb394-1" data-line-number="1"><span class="ot">(===) ::</span> (<span class="dt">Eq</span> a, <span class="dt">Show</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
-<div class="sourceCode" id="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb395-1" data-line-number="1"><span class="ot">propRevSmall ::</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb395-2" data-line-number="2">propRevSmall <span class="fu">=</span> rev [<span class="dv">1</span>,<span class="dv">2</span>] <span class="fu">===</span> [<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb394-1" title="1"><span class="ot">(===) ::</span> (<span class="dt">Eq</span> a, <span class="dt">Show</span> a) <span class="ot">=&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
+<div class="sourceCode" id="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb395-1" title="1"><span class="ot">propRevSmall ::</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb395-2" title="2">propRevSmall <span class="fu">=</span> rev [<span class="dv">1</span>,<span class="dv">2</span>] <span class="fu">===</span> [<span class="dv">2</span>,<span class="dv">1</span>]</a></code></pre></div>
 <p>We can ask QuickCheck to run them in GHCi:</p>
-<div class="sourceCode" id="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb396-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevSmall</a>
-<a class="sourceLine" id="cb396-2" data-line-number="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a></code></pre></div>
+<div class="sourceCode" id="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb396-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevSmall</a>
+<a class="sourceLine" id="cb396-2" title="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a></code></pre></div>
 <p>So far so good. However this isn’t really what QuickCheck was made for. QuickCheck was designed for <em>property-based testing</em> where you can state a property your code should have, and QuickCheck runs your code with randomized inputs, checking the property every time. What would be a simple property that a correct implementation of <code>reverse</code> has? Reversing a list twice should certainly give us back the same list. Let’s write it out:</p>
-<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb397-1" data-line-number="1"><span class="ot">propRevTwice ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb397-2" data-line-number="2">propRevTwice xs <span class="fu">=</span> rev (rev xs) <span class="fu">===</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb397-1" title="1"><span class="ot">propRevTwice ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb397-2" title="2">propRevTwice xs <span class="fu">=</span> rev (rev xs) <span class="fu">===</span> xs</a></code></pre></div>
 <p>Our <code>Property</code> has an argument, which means that QuickCheck will generate random values and run the test. We can use the <code>verboseCheck</code> function to see which values are run. We can also give a parameter to the test ourselves if we wish to check a specific value.</p>
-<div class="sourceCode" id="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb398-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwice</a>
-<a class="sourceLine" id="cb398-2" data-line-number="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a>
-<a class="sourceLine" id="cb398-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> verboseCheck propRevTwice</a>
-<a class="sourceLine" id="cb398-4" data-line-number="4"><span class="dt">Passed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb398-5" data-line-number="5">[]</a>
-<a class="sourceLine" id="cb398-6" data-line-number="6">[] <span class="fu">==</span> []</a>
-<a class="sourceLine" id="cb398-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb398-8" data-line-number="8"><span class="dt">Passed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb398-9" data-line-number="9">[<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb398-10" data-line-number="10">[<span class="dv">1</span>] <span class="fu">==</span> [<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb398-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb398-12" data-line-number="12"><span class="dt">Passed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb398-13" data-line-number="13">[<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb398-14" data-line-number="14">[<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>] <span class="fu">==</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb398-15" data-line-number="15"><span class="co">-- lots of output</span></a>
-<a class="sourceLine" id="cb398-16" data-line-number="16"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a>
-<a class="sourceLine" id="cb398-17" data-line-number="17"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (propRevTwice [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])</a>
-<a class="sourceLine" id="cb398-18" data-line-number="18"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a></code></pre></div>
+<div class="sourceCode" id="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb398-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwice</a>
+<a class="sourceLine" id="cb398-2" title="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a>
+<a class="sourceLine" id="cb398-3" title="3"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> verboseCheck propRevTwice</a>
+<a class="sourceLine" id="cb398-4" title="4"><span class="dt">Passed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb398-5" title="5">[]</a>
+<a class="sourceLine" id="cb398-6" title="6">[] <span class="fu">==</span> []</a>
+<a class="sourceLine" id="cb398-7" title="7"></a>
+<a class="sourceLine" id="cb398-8" title="8"><span class="dt">Passed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb398-9" title="9">[<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb398-10" title="10">[<span class="dv">1</span>] <span class="fu">==</span> [<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb398-11" title="11"></a>
+<a class="sourceLine" id="cb398-12" title="12"><span class="dt">Passed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb398-13" title="13">[<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb398-14" title="14">[<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>] <span class="fu">==</span> [<span class="fu">-</span><span class="dv">2</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb398-15" title="15"><span class="co">-- lots of output</span></a>
+<a class="sourceLine" id="cb398-16" title="16"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a>
+<a class="sourceLine" id="cb398-17" title="17"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (propRevTwice [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>])</a>
+<a class="sourceLine" id="cb398-18" title="18"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a></code></pre></div>
 <p>Even this property didn’t catch the bug in our implementation. Let’s try another one. Here’s a property about how <code>rev (xs ++ ys)</code> behaves. You might want to take a moment to convince yourself that it should hold for a correct <code>rev</code> function.</p>
-<div class="sourceCode" id="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb399-1" data-line-number="1"><span class="ot">propRevTwo ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb399-2" data-line-number="2">propRevTwo xs ys <span class="fu">=</span> rev (xs <span class="fu">++</span> ys) <span class="fu">===</span> rev ys <span class="fu">++</span> rev xs</a></code></pre></div>
+<div class="sourceCode" id="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb399-1" title="1"><span class="ot">propRevTwo ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb399-2" title="2">propRevTwo xs ys <span class="fu">=</span> rev (xs <span class="fu">++</span> ys) <span class="fu">===</span> rev ys <span class="fu">++</span> rev xs</a></code></pre></div>
 <p>Let’s see if it holds for our implementation:</p>
-<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb400-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwo</a>
-<a class="sourceLine" id="cb400-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">5</span> tests and <span class="dv">3</span> shrinks)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb400-3" data-line-number="3">[<span class="dv">0</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb400-4" data-line-number="4">[<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb400-5" data-line-number="5">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb400-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwo</a>
+<a class="sourceLine" id="cb400-2" title="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">5</span> tests <span class="fu">and</span> <span class="dv">3</span> shrinks)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb400-3" title="3">[<span class="dv">0</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb400-4" title="4">[<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb400-5" title="5">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
 <p>Finally, a failure! There’s a bit to unpack here. First off, QuickCheck tells us the arguments with which the property failed: they are <code>[0,0]</code> and <code>[1]</code>. We can check this ourselves:</p>
-<div class="sourceCode" id="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb401-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (propRevTwo [<span class="dv">0</span>,<span class="dv">0</span>] [<span class="dv">1</span>])</a>
-<a class="sourceLine" id="cb401-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb401-3" data-line-number="3">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb401-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (propRevTwo [<span class="dv">0</span>,<span class="dv">0</span>] [<span class="dv">1</span>])</a>
+<a class="sourceLine" id="cb401-2" title="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb401-3" title="3">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
 <p>Next up, what does “after 5 tests and 3 shrinks” mean? One of the cool things about QuickCheck is that when it finds a failure, it tries some related values in order to find a nicer, smaller failure. We can see this in action with <code>verboseShrinking</code>, which prints out all the failures QuickCheck goes through:</p>
-<div class="sourceCode" id="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb402-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (verboseShrinking propRevTwo)</a>
-<a class="sourceLine" id="cb402-2" data-line-number="2"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-3" data-line-number="3">[<span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-4" data-line-number="4">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-5" data-line-number="5">[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb402-7" data-line-number="7"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-8" data-line-number="8">[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-9" data-line-number="9">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-10" data-line-number="10">[<span class="fu">-</span><span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb402-11" data-line-number="11"></a>
-<a class="sourceLine" id="cb402-12" data-line-number="12"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-13" data-line-number="13">[<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-14" data-line-number="14">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-15" data-line-number="15">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="fu">-</span><span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-16" data-line-number="16"></a>
-<a class="sourceLine" id="cb402-17" data-line-number="17"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-18" data-line-number="18">[<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-19" data-line-number="19">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-20" data-line-number="20">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-21" data-line-number="21"></a>
-<a class="sourceLine" id="cb402-22" data-line-number="22"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-23" data-line-number="23">[<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-24" data-line-number="24">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-25" data-line-number="25">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-26" data-line-number="26"></a>
-<a class="sourceLine" id="cb402-27" data-line-number="27"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-28" data-line-number="28">[<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-29" data-line-number="29">[<span class="dv">0</span>,<span class="dv">4</span>]</a>
-<a class="sourceLine" id="cb402-30" data-line-number="30">[<span class="dv">0</span>,<span class="dv">4</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-31" data-line-number="31"></a>
-<a class="sourceLine" id="cb402-32" data-line-number="32"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-33" data-line-number="33">[<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-34" data-line-number="34">[<span class="dv">0</span>,<span class="dv">2</span>]</a>
-<a class="sourceLine" id="cb402-35" data-line-number="35">[<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">2</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-36" data-line-number="36"></a>
-<a class="sourceLine" id="cb402-37" data-line-number="37"><span class="dt">Failed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb402-38" data-line-number="38">[<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb402-39" data-line-number="39">[<span class="dv">0</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb402-40" data-line-number="40">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb402-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (verboseShrinking propRevTwo)</a>
+<a class="sourceLine" id="cb402-2" title="2"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-3" title="3">[<span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-4" title="4">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-5" title="5">[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-6" title="6"></a>
+<a class="sourceLine" id="cb402-7" title="7"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-8" title="8">[<span class="fu">-</span><span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-9" title="9">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-10" title="10">[<span class="fu">-</span><span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>,<span class="fu">-</span><span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb402-11" title="11"></a>
+<a class="sourceLine" id="cb402-12" title="12"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-13" title="13">[<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-14" title="14">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-15" title="15">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="fu">-</span><span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="fu">-</span><span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-16" title="16"></a>
+<a class="sourceLine" id="cb402-17" title="17"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-18" title="18">[<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-19" title="19">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-20" title="20">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">4</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-21" title="21"></a>
+<a class="sourceLine" id="cb402-22" title="22"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-23" title="23">[<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-24" title="24">[<span class="dv">1</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-25" title="25">[<span class="dv">1</span>,<span class="dv">4</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">1</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-26" title="26"></a>
+<a class="sourceLine" id="cb402-27" title="27"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-28" title="28">[<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-29" title="29">[<span class="dv">0</span>,<span class="dv">4</span>]</a>
+<a class="sourceLine" id="cb402-30" title="30">[<span class="dv">0</span>,<span class="dv">4</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">4</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-31" title="31"></a>
+<a class="sourceLine" id="cb402-32" title="32"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-33" title="33">[<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-34" title="34">[<span class="dv">0</span>,<span class="dv">2</span>]</a>
+<a class="sourceLine" id="cb402-35" title="35">[<span class="dv">0</span>,<span class="dv">2</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">2</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-36" title="36"></a>
+<a class="sourceLine" id="cb402-37" title="37"><span class="dt">Failed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb402-38" title="38">[<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb402-39" title="39">[<span class="dv">0</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb402-40" title="40">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
 <p>QuickCheck went down from a counterexample of <code>[4,1,-1,4,4]</code> all the way to <code>[1,0,0]</code>. Pretty sweet!</p>
 <h3 id="modifiers"><span class="header-section-number">16.1.1</span> Modifiers</h3>
 <p>Sometimes you need to limit the values QuickCheck generates. Your function might not work on all inputs, for instance? Let’s try writing a test for <code>last</code>.</p>
-<div class="sourceCode" id="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb403-1" data-line-number="1"><span class="ot">propLast ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb403-2" data-line-number="2">propLast xs <span class="fu">=</span> last xs <span class="fu">===</span> head (reverse xs)</a></code></pre></div>
-<div class="sourceCode" id="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb404-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propLast</a>
-<a class="sourceLine" id="cb404-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Exception</span><span class="fu">:</span> <span class="ch">&#39;Prelude.last: empty list&#39;</span> (after <span class="dv">1</span> test)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb404-3" data-line-number="3">[]</a></code></pre></div>
+<div class="sourceCode" id="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb403-1" title="1"><span class="ot">propLast ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb403-2" title="2">propLast xs <span class="fu">=</span> <span class="fu">last</span> xs <span class="fu">===</span> <span class="fu">head</span> (<span class="fu">reverse</span> xs)</a></code></pre></div>
+<div class="sourceCode" id="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb404-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propLast</a>
+<a class="sourceLine" id="cb404-2" title="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Exception</span><span class="fu">:</span> <span class="dt">&#39;Prelude</span><span class="fu">.last:</span> empty list&#39; (after <span class="dv">1</span> test)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb404-3" title="3">[]</a></code></pre></div>
 <p>In this case, we can fix the test just by switching to another input type. QuickCheck defines the <code>NonEmptyList</code> type (not to be confused with <code>Data.List.NonEmpty</code>!), which is just a wrapper for a normal list. However, when generating values of <code>NonEmptyList</code>, QuickCheck won’t generate empty lists.</p>
-<div class="sourceCode" id="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb405-1" data-line-number="1"><span class="kw">newtype</span> <span class="dt">NonEmptyList</span> a <span class="fu">=</span> <span class="dt">NonEmpty</span> [a]</a></code></pre></div>
-<div class="sourceCode" id="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb406-1" data-line-number="1"><span class="ot">propLastFixed ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb406-2" data-line-number="2">propLastFixed (<span class="dt">NonEmpty</span> xs) <span class="fu">=</span> last xs <span class="fu">===</span> head (reverse xs)</a></code></pre></div>
-<div class="sourceCode" id="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb407-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propLastFixed</a>
-<a class="sourceLine" id="cb407-2" data-line-number="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
+<div class="sourceCode" id="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb405-1" title="1"><span class="kw">newtype</span> <span class="dt">NonEmptyList</span> a <span class="fu">=</span> <span class="dt">NonEmpty</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb406-1" title="1"><span class="ot">propLastFixed ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb406-2" title="2">propLastFixed (<span class="dt">NonEmpty</span> xs) <span class="fu">=</span> <span class="fu">last</span> xs <span class="fu">===</span> <span class="fu">head</span> (<span class="fu">reverse</span> xs)</a></code></pre></div>
+<div class="sourceCode" id="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb407-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propLastFixed</a>
+<a class="sourceLine" id="cb407-2" title="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
 <p>There are <a href="https://hackage.haskell.org/package/QuickCheck-2.14.2/docs/Test-QuickCheck.html#g:16">other modifiers</a> like this, for example <code>Positive</code> for positive numbers, <code>NonNegative</code> for non-negative numbers, or <code>SortedList</code> for a sorted list. Here’s an example of a more complex test. We check that the nth element of <code>cycle xs</code> is correct. Both of the modifiers are needed, since <code>!!</code> doesn’t work with negative inputs, and <code>cycle []</code> is an error.</p>
-<div class="sourceCode" id="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb408-1" data-line-number="1"><span class="ot">propCycle ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">NonNegative</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb408-2" data-line-number="2">propCycle (<span class="dt">NonEmpty</span> xs) (<span class="dt">NonNegative</span> n) <span class="fu">=</span></a>
-<a class="sourceLine" id="cb408-3" data-line-number="3">  cycle xs <span class="fu">!!</span> n <span class="fu">===</span> xs <span class="fu">!!</span> (mod n (length xs))</a></code></pre></div>
+<div class="sourceCode" id="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb408-1" title="1"><span class="ot">propCycle ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">NonNegative</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb408-2" title="2">propCycle (<span class="dt">NonEmpty</span> xs) (<span class="dt">NonNegative</span> n) <span class="fu">=</span></a>
+<a class="sourceLine" id="cb408-3" title="3">  <span class="fu">cycle</span> xs <span class="fu">!!</span> n <span class="fu">===</span> xs <span class="fu">!!</span> (<span class="fu">mod</span> n (<span class="fu">length</span> xs))</a></code></pre></div>
 <h3 id="generators-and-forall"><span class="header-section-number">16.1.2</span> Generators and <code>forAll</code></h3>
 <p>Sometimes we need to limit the range of inputs to a test even further. As a simple example, here’s a test that <code>Data.Char.toUpper</code> changes the character passed to it:</p>
-<div class="sourceCode" id="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb409-1" data-line-number="1"><span class="ot">propToUpperChanges ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb409-2" data-line-number="2">propToUpperChanges c <span class="fu">=</span> toUpper c <span class="fu">=/=</span> c</a></code></pre></div>
-<div class="sourceCode" id="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb410-1" data-line-number="1">quickCheck propToUpperChanges</a>
-<a class="sourceLine" id="cb410-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test and <span class="dv">1</span> shrink)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb410-3" data-line-number="3"><span class="ch">&#39;A&#39;</span></a>
-<a class="sourceLine" id="cb410-4" data-line-number="4"><span class="ch">&#39;A&#39;</span> <span class="fu">==</span> <span class="ch">&#39;A&#39;</span></a></code></pre></div>
+<div class="sourceCode" id="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb409-1" title="1"><span class="ot">propToUpperChanges ::</span> <span class="dt">Char</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb409-2" title="2">propToUpperChanges c <span class="fu">=</span> <span class="fu">toUpper</span> c <span class="fu">=/=</span> c</a></code></pre></div>
+<div class="sourceCode" id="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb410-1" title="1">quickCheck propToUpperChanges</a>
+<a class="sourceLine" id="cb410-2" title="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test <span class="fu">and</span> <span class="dv">1</span> shrink)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb410-3" title="3"><span class="ch">&#39;A&#39;</span></a>
+<a class="sourceLine" id="cb410-4" title="4"><span class="ch">&#39;A&#39;</span> <span class="fu">==</span> <span class="ch">&#39;A&#39;</span></a></code></pre></div>
 <p>Of course, it only changes <em>lowercase letters</em>. How can we write a test for that? There is no <code>Lowercase</code> modifier available that would work like <code>Positive</code> or <code>NonEmptyList</code>. We need to fall back to explicit generation of values using <code>forAll</code>:</p>
-<div class="sourceCode" id="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb411-1" data-line-number="1"><span class="ot">propToUpperChangesLetter ::</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb411-2" data-line-number="2">propToUpperChangesLetter <span class="fu">=</span> forAll (elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>]) propToUpperChanges</a></code></pre></div>
-<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb412-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> verboseCheck propToUpperChangesLetter</a>
-<a class="sourceLine" id="cb412-2" data-line-number="2"><span class="dt">Passed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb412-3" data-line-number="3"><span class="ch">&#39;s&#39;</span></a>
-<a class="sourceLine" id="cb412-4" data-line-number="4"><span class="ch">&#39;S&#39;</span> <span class="fu">/=</span> <span class="ch">&#39;s&#39;</span></a>
-<a class="sourceLine" id="cb412-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb412-6" data-line-number="6"><span class="dt">Passed</span><span class="fu">:</span></a>
-<a class="sourceLine" id="cb412-7" data-line-number="7"><span class="ch">&#39;z&#39;</span></a>
-<a class="sourceLine" id="cb412-8" data-line-number="8"><span class="ch">&#39;Z&#39;</span> <span class="fu">/=</span> <span class="ch">&#39;z&#39;</span></a>
-<a class="sourceLine" id="cb412-9" data-line-number="9"><span class="co">-- lots of output omitted</span></a>
-<a class="sourceLine" id="cb412-10" data-line-number="10"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
+<div class="sourceCode" id="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb411-1" title="1"><span class="ot">propToUpperChangesLetter ::</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb411-2" title="2">propToUpperChangesLetter <span class="fu">=</span> forAll (elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>]) propToUpperChanges</a></code></pre></div>
+<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb412-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> verboseCheck propToUpperChangesLetter</a>
+<a class="sourceLine" id="cb412-2" title="2"><span class="dt">Passed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb412-3" title="3"><span class="ch">&#39;s&#39;</span></a>
+<a class="sourceLine" id="cb412-4" title="4"><span class="ch">&#39;S&#39;</span> <span class="fu">/=</span> <span class="ch">&#39;s&#39;</span></a>
+<a class="sourceLine" id="cb412-5" title="5"></a>
+<a class="sourceLine" id="cb412-6" title="6"><span class="dt">Passed</span><span class="fu">:</span></a>
+<a class="sourceLine" id="cb412-7" title="7"><span class="ch">&#39;z&#39;</span></a>
+<a class="sourceLine" id="cb412-8" title="8"><span class="ch">&#39;Z&#39;</span> <span class="fu">/=</span> <span class="ch">&#39;z&#39;</span></a>
+<a class="sourceLine" id="cb412-9" title="9"><span class="co">-- lots of output omitted</span></a>
+<a class="sourceLine" id="cb412-10" title="10"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
 <p>Perfect! Let’s look at the types to see what’s going on here.</p>
-<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb413-1" data-line-number="1"><span class="ot">elements ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Gen</span> a</a>
-<a class="sourceLine" id="cb413-2" data-line-number="2">elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>]<span class="ot"> ::</span> <span class="dt">Gen</span> <span class="dt">Char</span></a>
-<a class="sourceLine" id="cb413-3" data-line-number="3"><span class="ot">forAll ::</span> (<span class="dt">Show</span> a, <span class="dt">Testable</span> prop) <span class="ot">=&gt;</span> <span class="dt">Gen</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> prop) <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb413-4" data-line-number="4">forAll (elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>])<span class="ot"> ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> (<span class="dt">Char</span> <span class="ot">-&gt;</span> prop) <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
+<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb413-1" title="1"><span class="ot">elements ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Gen</span> a</a>
+<a class="sourceLine" id="cb413-2" title="2">elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>]<span class="ot"> ::</span> <span class="dt">Gen</span> <span class="dt">Char</span></a>
+<a class="sourceLine" id="cb413-3" title="3"><span class="ot">forAll ::</span> (<span class="dt">Show</span> a, <span class="dt">Testable</span> prop) <span class="ot">=&gt;</span> <span class="dt">Gen</span> a <span class="ot">-&gt;</span> (a <span class="ot">-&gt;</span> prop) <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb413-4" title="4">forAll (elements [<span class="ch">&#39;a&#39;</span><span class="fu">..</span><span class="ch">&#39;z&#39;</span>])<span class="ot"> ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> (<span class="dt">Char</span> <span class="ot">-&gt;</span> prop) <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
 <p>There are some new types here. A value of type <code>Gen a</code> is a generator for values of type <code>a</code>. We’ll talk a bit more about <code>Gen</code> in the next section, but in this section you’ll see a couple of functions that return <code>Gen</code>s so that we can use them with <code>forAll</code>. The <code>elements</code> function is a generator that returns one of the elements of the given list at random, as you might have guessed.</p>
 <p>The <code>Testable</code> type class is the same that the <code>quickCheck</code> function uses. It exists so that <code>quickCheck</code> can test types like <code>[Int] -&gt; Bool -&gt; Property</code> in addition to just plain <code>Property</code> values.</p>
-<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb414-1" data-line-number="1"><span class="ot">quickCheck ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> prop <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
+<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb414-1" title="1"><span class="ot">quickCheck ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> prop <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a></code></pre></div>
 <p>In addition, some simple types like <code>Bool</code> have a <code>Testable</code> instance, so that you can write tests using normal Haskell predicates instead of <code>===</code>:</p>
-<div class="sourceCode" id="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb415-1" data-line-number="1"><span class="ot">listHasZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
-<a class="sourceLine" id="cb415-2" data-line-number="2">listHasZero xs <span class="fu">=</span> elem <span class="dv">0</span> xs</a></code></pre></div>
-<div class="sourceCode" id="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb416-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (listHasZero [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">2</span>])</a>
-<a class="sourceLine" id="cb416-2" data-line-number="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a>
-<a class="sourceLine" id="cb416-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck listHasZero</a>
-<a class="sourceLine" id="cb416-4" data-line-number="4"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb416-5" data-line-number="5">[]</a></code></pre></div>
+<div class="sourceCode" id="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb415-1" title="1"><span class="ot">listHasZero ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Bool</span></a>
+<a class="sourceLine" id="cb415-2" title="2">listHasZero xs <span class="fu">=</span> <span class="fu">elem</span> <span class="dv">0</span> xs</a></code></pre></div>
+<div class="sourceCode" id="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb416-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (listHasZero [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">2</span>])</a>
+<a class="sourceLine" id="cb416-2" title="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">1</span> test<span class="fu">.</span></a>
+<a class="sourceLine" id="cb416-3" title="3"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck listHasZero</a>
+<a class="sourceLine" id="cb416-4" title="4"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">1</span> test)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb416-5" title="5">[]</a></code></pre></div>
 <p>Getting back to <code>forAll</code>, we can use <code>forAll</code> to write more complex tests. Here’s a test that checks that <code>sort xs</code> has the same elements as <code>xs</code>. Note how we use <code>NonEmptyList</code> to guarantee that the <code>forAll</code> has some elements to pick from.</p>
-<div class="sourceCode" id="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb417-1" data-line-number="1"><span class="ot">propSort ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb417-2" data-line-number="2">propSort (<span class="dt">NonEmpty</span> xs) <span class="fu">=</span></a>
-<a class="sourceLine" id="cb417-3" data-line-number="3">  forAll (elements xs) (\x <span class="ot">-&gt;</span> elem x (sort xs))</a></code></pre></div>
+<div class="sourceCode" id="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb417-1" title="1"><span class="ot">propSort ::</span> <span class="dt">NonEmptyList</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb417-2" title="2">propSort (<span class="dt">NonEmpty</span> xs) <span class="fu">=</span></a>
+<a class="sourceLine" id="cb417-3" title="3">  forAll (elements xs) (\x <span class="ot">-&gt;</span> <span class="fu">elem</span> x (<span class="fu">sort</span> xs))</a></code></pre></div>
 <h3 id="further-with-quickcheck"><span class="header-section-number">16.1.3</span> Further with QuickCheck</h3>
 <p>We’ve only just scratched the surface of QuickCheck. Here are some pointers to some things you’ll find useful when you start writing larger QuickCheck tests.</p>
 <p>Sometimes the output from QuickCheck isn’t quite verbose enough. You can add your own lines to the output by using the <code>counterexample</code> combinator:</p>
-<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb418-1" data-line-number="1"><span class="ot">counterexample ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> prop <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
+<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb418-1" title="1"><span class="ot">counterexample ::</span> <span class="dt">Testable</span> prop <span class="ot">=&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> prop <span class="ot">-&gt;</span> <span class="dt">Property</span></a></code></pre></div>
 <p>As an example, let’s add logging of the input to <code>rev</code> to <code>propRevTwo</code>:</p>
-<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb419-1" data-line-number="1"><span class="ot">propRevTwo&#39; ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb419-2" data-line-number="2">propRevTwo&#39; xs ys <span class="fu">=</span></a>
-<a class="sourceLine" id="cb419-3" data-line-number="3">  <span class="kw">let</span> input <span class="fu">=</span> xs <span class="fu">++</span> ys</a>
-<a class="sourceLine" id="cb419-4" data-line-number="4">  <span class="kw">in</span> counterexample (<span class="st">&quot;Input: &quot;</span> <span class="fu">++</span> show input) <span class="fu">$</span></a>
-<a class="sourceLine" id="cb419-5" data-line-number="5">     rev input <span class="fu">===</span> rev ys <span class="fu">++</span> rev xs</a></code></pre></div>
-<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb420-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwo&#39;</a>
-<a class="sourceLine" id="cb420-2" data-line-number="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">4</span> tests and <span class="dv">5</span> shrinks)<span class="fu">:</span></a>
-<a class="sourceLine" id="cb420-3" data-line-number="3">[<span class="dv">0</span>]</a>
-<a class="sourceLine" id="cb420-4" data-line-number="4">[<span class="dv">0</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb420-5" data-line-number="5"><span class="dt">Input</span><span class="fu">:</span> [<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">1</span>]</a>
-<a class="sourceLine" id="cb420-6" data-line-number="6">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb419-1" title="1"><span class="ot">propRevTwo&#39; ::</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> [<span class="dt">Int</span>] <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb419-2" title="2">propRevTwo&#39; xs ys <span class="fu">=</span></a>
+<a class="sourceLine" id="cb419-3" title="3">  <span class="kw">let</span> input <span class="fu">=</span> xs <span class="fu">++</span> ys</a>
+<a class="sourceLine" id="cb419-4" title="4">  <span class="kw">in</span> counterexample (<span class="st">&quot;Input: &quot;</span> <span class="fu">++</span> <span class="fu">show</span> input) <span class="fu">$</span></a>
+<a class="sourceLine" id="cb419-5" title="5">     rev input <span class="fu">===</span> rev ys <span class="fu">++</span> rev xs</a></code></pre></div>
+<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb420-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propRevTwo&#39;</a>
+<a class="sourceLine" id="cb420-2" title="2"><span class="fu">***</span> <span class="dt">Failed</span><span class="fu">!</span> <span class="dt">Falsified</span> (after <span class="dv">4</span> tests <span class="fu">and</span> <span class="dv">5</span> shrinks)<span class="fu">:</span></a>
+<a class="sourceLine" id="cb420-3" title="3">[<span class="dv">0</span>]</a>
+<a class="sourceLine" id="cb420-4" title="4">[<span class="dv">0</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb420-5" title="5"><span class="dt">Input</span><span class="fu">:</span> [<span class="dv">0</span>,<span class="dv">0</span>,<span class="dv">1</span>]</a>
+<a class="sourceLine" id="cb420-6" title="6">[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">0</span>] <span class="fu">/=</span> [<span class="dv">1</span>,<span class="dv">0</span>,<span class="dv">0</span>]</a></code></pre></div>
 <p>As you might have guessed, <code>Gen</code> is a <code>Monad</code>. You can write your own generators by combining the generators defined by QuickCheck. You can check what your generators output using <code>sample</code>.</p>
-<div class="sourceCode" id="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb421-1" data-line-number="1"><span class="ot">someLetters ::</span> <span class="dt">Gen</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb421-2" data-line-number="2">someLetters <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb421-3" data-line-number="3">  c <span class="ot">&lt;-</span> elements <span class="st">&quot;xyzw&quot;</span></a>
-<a class="sourceLine" id="cb421-4" data-line-number="4">  n <span class="ot">&lt;-</span> choose (<span class="dv">1</span>,<span class="dv">10</span>)</a>
-<a class="sourceLine" id="cb421-5" data-line-number="5">  return (replicate n c)</a></code></pre></div>
-<div class="sourceCode" id="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb422-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> sample someLetters</a>
-<a class="sourceLine" id="cb422-2" data-line-number="2"><span class="st">&quot;yyyyyyyy&quot;</span></a>
-<a class="sourceLine" id="cb422-3" data-line-number="3"><span class="st">&quot;zzzzzzzzz&quot;</span></a>
-<a class="sourceLine" id="cb422-4" data-line-number="4"><span class="st">&quot;xxxxxxxxx&quot;</span></a>
-<a class="sourceLine" id="cb422-5" data-line-number="5"><span class="st">&quot;yyyyyyy&quot;</span></a>
-<a class="sourceLine" id="cb422-6" data-line-number="6"><span class="st">&quot;yyy&quot;</span></a>
-<a class="sourceLine" id="cb422-7" data-line-number="7"><span class="st">&quot;ww&quot;</span></a>
-<a class="sourceLine" id="cb422-8" data-line-number="8"><span class="st">&quot;xxxxxx&quot;</span></a>
-<a class="sourceLine" id="cb422-9" data-line-number="9"><span class="st">&quot;yyy&quot;</span></a>
-<a class="sourceLine" id="cb422-10" data-line-number="10"><span class="st">&quot;yyyyyyy&quot;</span></a>
-<a class="sourceLine" id="cb422-11" data-line-number="11"><span class="st">&quot;xxxxxxxxxx&quot;</span></a>
-<a class="sourceLine" id="cb422-12" data-line-number="12"><span class="st">&quot;y&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb421-1" title="1"><span class="ot">someLetters ::</span> <span class="dt">Gen</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb421-2" title="2">someLetters <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb421-3" title="3">  c <span class="ot">&lt;-</span> elements <span class="st">&quot;xyzw&quot;</span></a>
+<a class="sourceLine" id="cb421-4" title="4">  n <span class="ot">&lt;-</span> choose (<span class="dv">1</span>,<span class="dv">10</span>)</a>
+<a class="sourceLine" id="cb421-5" title="5">  <span class="fu">return</span> (<span class="fu">replicate</span> n c)</a></code></pre></div>
+<div class="sourceCode" id="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb422-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> sample someLetters</a>
+<a class="sourceLine" id="cb422-2" title="2"><span class="st">&quot;yyyyyyyy&quot;</span></a>
+<a class="sourceLine" id="cb422-3" title="3"><span class="st">&quot;zzzzzzzzz&quot;</span></a>
+<a class="sourceLine" id="cb422-4" title="4"><span class="st">&quot;xxxxxxxxx&quot;</span></a>
+<a class="sourceLine" id="cb422-5" title="5"><span class="st">&quot;yyyyyyy&quot;</span></a>
+<a class="sourceLine" id="cb422-6" title="6"><span class="st">&quot;yyy&quot;</span></a>
+<a class="sourceLine" id="cb422-7" title="7"><span class="st">&quot;ww&quot;</span></a>
+<a class="sourceLine" id="cb422-8" title="8"><span class="st">&quot;xxxxxx&quot;</span></a>
+<a class="sourceLine" id="cb422-9" title="9"><span class="st">&quot;yyy&quot;</span></a>
+<a class="sourceLine" id="cb422-10" title="10"><span class="st">&quot;yyyyyyy&quot;</span></a>
+<a class="sourceLine" id="cb422-11" title="11"><span class="st">&quot;xxxxxxxxxx&quot;</span></a>
+<a class="sourceLine" id="cb422-12" title="12"><span class="st">&quot;y&quot;</span></a></code></pre></div>
 <p>Closely related to generators is the <code>Arbitrary</code> type class. <code>Arbitrary</code> is how QuickCheck generates all those inputs automatically.</p>
-<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb423-1" data-line-number="1"><span class="kw">class</span> <span class="dt">Arbitrary</span> a <span class="kw">where</span></a>
-<a class="sourceLine" id="cb423-2" data-line-number="2"><span class="ot">  arbitrary ::</span> <span class="dt">Gen</span> a</a>
-<a class="sourceLine" id="cb423-3" data-line-number="3"><span class="ot">  shrink ::</span> a <span class="ot">-&gt;</span> [a]</a></code></pre></div>
+<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb423-1" title="1"><span class="kw">class</span> <span class="dt">Arbitrary</span> a <span class="kw">where</span></a>
+<a class="sourceLine" id="cb423-2" title="2"><span class="ot">  arbitrary ::</span> <span class="dt">Gen</span> a</a>
+<a class="sourceLine" id="cb423-3" title="3"><span class="ot">  shrink ::</span> a <span class="ot">-&gt;</span> [a]</a></code></pre></div>
 <p>If you’re writing tests for custom types, you either need to use <code>forAll</code>, or implement an <code>Arbitrary</code> instance. Here’s what happens if you’re missing an instance:</p>
-<div class="sourceCode" id="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb424-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Switch</span> <span class="fu">=</span> <span class="dt">On</span> <span class="fu">|</span> <span class="dt">Off</span></a>
-<a class="sourceLine" id="cb424-2" data-line-number="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
-<a class="sourceLine" id="cb424-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb424-4" data-line-number="4"><span class="ot">toggle ::</span> <span class="dt">Switch</span> <span class="ot">-&gt;</span> <span class="dt">Switch</span></a>
-<a class="sourceLine" id="cb424-5" data-line-number="5">toggle <span class="dt">On</span> <span class="fu">=</span> <span class="dt">Off</span></a>
-<a class="sourceLine" id="cb424-6" data-line-number="6">toggle <span class="dt">Off</span> <span class="fu">=</span> <span class="dt">On</span></a>
-<a class="sourceLine" id="cb424-7" data-line-number="7"></a>
-<a class="sourceLine" id="cb424-8" data-line-number="8"><span class="ot">propToggleTwice ::</span> <span class="dt">Switch</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
-<a class="sourceLine" id="cb424-9" data-line-number="9">propToggleTwice s <span class="fu">=</span> s <span class="fu">===</span> toggle (toggle s)</a></code></pre></div>
-<div class="sourceCode" id="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb425-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propToggleTwice</a>
-<a class="sourceLine" id="cb425-2" data-line-number="2">error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb425-3" data-line-number="3">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Arbitrary</span> <span class="dt">Switch</span>)</a>
-<a class="sourceLine" id="cb425-4" data-line-number="4">        arising from a use <span class="kw">of</span> ‘quickCheck’</a>
-<a class="sourceLine" id="cb425-5" data-line-number="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> quickCheck propToggleTwice</a></code></pre></div>
+<div class="sourceCode" id="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb424-1" title="1"><span class="kw">data</span> <span class="dt">Switch</span> <span class="fu">=</span> <span class="dt">On</span> <span class="fu">|</span> <span class="dt">Off</span></a>
+<a class="sourceLine" id="cb424-2" title="2">  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</a>
+<a class="sourceLine" id="cb424-3" title="3"></a>
+<a class="sourceLine" id="cb424-4" title="4"><span class="ot">toggle ::</span> <span class="dt">Switch</span> <span class="ot">-&gt;</span> <span class="dt">Switch</span></a>
+<a class="sourceLine" id="cb424-5" title="5">toggle <span class="dt">On</span> <span class="fu">=</span> <span class="dt">Off</span></a>
+<a class="sourceLine" id="cb424-6" title="6">toggle <span class="dt">Off</span> <span class="fu">=</span> <span class="dt">On</span></a>
+<a class="sourceLine" id="cb424-7" title="7"></a>
+<a class="sourceLine" id="cb424-8" title="8"><span class="ot">propToggleTwice ::</span> <span class="dt">Switch</span> <span class="ot">-&gt;</span> <span class="dt">Property</span></a>
+<a class="sourceLine" id="cb424-9" title="9">propToggleTwice s <span class="fu">=</span> s <span class="fu">===</span> toggle (toggle s)</a></code></pre></div>
+<div class="sourceCode" id="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb425-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck propToggleTwice</a>
+<a class="sourceLine" id="cb425-2" title="2"><span class="fu">error:</span></a>
+<a class="sourceLine" id="cb425-3" title="3">    • <span class="dt">No</span> <span class="kw">instance</span> for (<span class="dt">Arbitrary</span> <span class="dt">Switch</span>)</a>
+<a class="sourceLine" id="cb425-4" title="4">        arising from a use <span class="kw">of</span> ‘quickCheck’</a>
+<a class="sourceLine" id="cb425-5" title="5">    • <span class="dt">In</span> the expression<span class="fu">:</span> quickCheck propToggleTwice</a></code></pre></div>
 <p>Here are the two ways to fix it:</p>
-<div class="sourceCode" id="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb426-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (forAll (elements [<span class="dt">On</span>,<span class="dt">Off</span>]) propToggleTwice)</a>
-<a class="sourceLine" id="cb426-2" data-line-number="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
-<div class="sourceCode" id="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb427-1" data-line-number="1"><span class="kw">instance</span> <span class="dt">Arbitrary</span> <span class="dt">Switch</span> <span class="kw">where</span></a>
-<a class="sourceLine" id="cb427-2" data-line-number="2">  arbitrary <span class="fu">=</span> elements [<span class="dt">On</span>,<span class="dt">Off</span>]</a></code></pre></div>
+<div class="sourceCode" id="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb426-1" title="1"><span class="fu">*</span><span class="dt">Examples.QuickCheck</span><span class="fu">&gt;</span> quickCheck (forAll (elements [<span class="dt">On</span>,<span class="dt">Off</span>]) propToggleTwice)</a>
+<a class="sourceLine" id="cb426-2" title="2"><span class="fu">+++</span> <span class="dt">OK</span>, passed <span class="dv">100</span> tests<span class="fu">.</span></a></code></pre></div>
+<div class="sourceCode" id="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb427-1" title="1"><span class="kw">instance</span> <span class="dt">Arbitrary</span> <span class="dt">Switch</span> <span class="kw">where</span></a>
+<a class="sourceLine" id="cb427-2" title="2">  arbitrary <span class="fu">=</span> elements [<span class="dt">On</span>,<span class="dt">Off</span>]</a></code></pre></div>
 <!-- TODO (==>)? -->
 <h2 id="phantom-types"><span class="header-section-number">16.2</span> Phantom Types</h2>
 <p>Boo! There’s a ghost in the type system! Let’s have a look at what <em>phantom types</em> can do for you.</p>
 <p>Phantom types are types that don’t take any values. They are related to newtypes (see lecture 10) in that both are a way to add additional type checking without affecting the evaluation of the program at all.</p>
 <p>Let’s use phantom types to track which currency an amount of money is in. We define the phantom types <code>EUR</code> and <code>USD</code> (note how they don’t have any constructors!), and the parameterized type <code>Money a</code> that doesn’t use the type parameter <code>a</code> for anything. Then we can define two constants, one in euros and the other in dollars. You can find all of the code from this section in the file <a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Examples/Phantom.hs"><code>exercises/Examples/Phantom.hs</code></a>.</p>
-<div class="sourceCode" id="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb428-1" data-line-number="1"><span class="kw">data</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb428-2" data-line-number="2"><span class="kw">data</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb428-3" data-line-number="3"><span class="kw">data</span> <span class="dt">Money</span> currency <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb428-4" data-line-number="4">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb428-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb428-6" data-line-number="6"><span class="ot">dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb428-7" data-line-number="7">dollar <span class="fu">=</span> <span class="dt">Money</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb428-8" data-line-number="8"></a>
-<a class="sourceLine" id="cb428-9" data-line-number="9"><span class="ot">twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb428-10" data-line-number="10">twoEuros <span class="fu">=</span> <span class="dt">Money</span> <span class="dv">2</span></a></code></pre></div>
+<div class="sourceCode" id="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb428-1" title="1"><span class="kw">data</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb428-2" title="2"><span class="kw">data</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb428-3" title="3"><span class="kw">data</span> <span class="dt">Money</span> currency <span class="fu">=</span> <span class="dt">Money</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb428-4" title="4">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb428-5" title="5"></a>
+<a class="sourceLine" id="cb428-6" title="6"><span class="ot">dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb428-7" title="7">dollar <span class="fu">=</span> <span class="dt">Money</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb428-8" title="8"></a>
+<a class="sourceLine" id="cb428-9" title="9"><span class="ot">twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb428-10" title="10">twoEuros <span class="fu">=</span> <span class="dt">Money</span> <span class="dv">2</span></a></code></pre></div>
 <p>Note how the type signatures for <code>dollar</code> and <code>twoEuros</code> are doing all the work here. An expression like <code>Money 1</code> has the polymorphic type <code>Money currency</code> if we don’t restrict it to a more specific type. We give <code>dollar</code> and <code>twoEuros</code> more limited types explicitly. This is analogous to defining something like <code>one :: Int; one = 1</code>, since the constant <code>1</code> has the polymorphic type <code>Num p =&gt; p</code> but we give it a more restricted type.</p>
-<div class="sourceCode" id="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb429-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Money</span></a>
-<a class="sourceLine" id="cb429-2" data-line-number="2"><span class="dt">Money</span><span class="ot"> ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
-<a class="sourceLine" id="cb429-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Money</span> <span class="dv">1</span></a>
-<a class="sourceLine" id="cb429-4" data-line-number="4"><span class="dt">Money</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Money</span> currency</a></code></pre></div>
+<div class="sourceCode" id="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb429-1" title="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Money</span></a>
+<a class="sourceLine" id="cb429-2" title="2"><span class="dt">Money</span><span class="ot"> ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
+<a class="sourceLine" id="cb429-3" title="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t <span class="dt">Money</span> <span class="dv">1</span></a>
+<a class="sourceLine" id="cb429-4" title="4"><span class="dt">Money</span> <span class="dv">1</span><span class="ot"> ::</span> <span class="dt">Money</span> currency</a></code></pre></div>
 <p>Now that we have some constants, we can write functions that operate on them. Let’s start with a function <code>scaleMoney</code> that multiplies an amount of money by a number. The currency stays constant. Here too, the type signature is doing the work: without the type signature, Haskell would infer a type of <code>Double -&gt; Money a -&gt; Money b</code>.</p>
-<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb430-1" data-line-number="1"><span class="ot">scaleMoney ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
-<a class="sourceLine" id="cb430-2" data-line-number="2">scaleMoney factor (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (factor <span class="fu">*</span> a)</a></code></pre></div>
-<div class="sourceCode" id="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb431-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t scaleMoney <span class="dv">3</span> twoEuros</a>
-<a class="sourceLine" id="cb431-2" data-line-number="2">scaleMoney <span class="dv">3</span><span class="ot"> twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb431-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t scaleMoney <span class="dv">3</span> dollar</a>
-<a class="sourceLine" id="cb431-4" data-line-number="4">scaleMoney <span class="dv">3</span><span class="ot"> dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a></code></pre></div>
+<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb430-1" title="1"><span class="ot">scaleMoney ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
+<a class="sourceLine" id="cb430-2" title="2">scaleMoney factor (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (factor <span class="fu">*</span> a)</a></code></pre></div>
+<div class="sourceCode" id="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb431-1" title="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t scaleMoney <span class="dv">3</span> twoEuros</a>
+<a class="sourceLine" id="cb431-2" title="2">scaleMoney <span class="dv">3</span><span class="ot"> twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb431-3" title="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t scaleMoney <span class="dv">3</span> dollar</a>
+<a class="sourceLine" id="cb431-4" title="4">scaleMoney <span class="dv">3</span><span class="ot"> dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a></code></pre></div>
 <p>Next up: adding two amounts that are in the same currency. We get a nice type error if we try to add values in two different currencies.</p>
-<div class="sourceCode" id="cb432"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb432-1" data-line-number="1"><span class="ot">addMoney ::</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
-<a class="sourceLine" id="cb432-2" data-line-number="2">addMoney (<span class="dt">Money</span> a) (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a></code></pre></div>
-<div class="sourceCode" id="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb433-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney dollar dollar</a>
-<a class="sourceLine" id="cb433-2" data-line-number="2">addMoney dollar<span class="ot"> dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb433-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney twoEuros twoEuros</a>
-<a class="sourceLine" id="cb433-4" data-line-number="4">addMoney twoEuros<span class="ot"> twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb433-5" data-line-number="5"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney twoEuros dollar</a>
-<a class="sourceLine" id="cb433-6" data-line-number="6">error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb433-7" data-line-number="7">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘<span class="dt">USD</span>’ with ‘<span class="dt">EUR</span>’</a>
-<a class="sourceLine" id="cb433-8" data-line-number="8">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb433-9" data-line-number="9">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb433-10" data-line-number="10">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘addMoney’, namely ‘dollar’</a>
-<a class="sourceLine" id="cb433-11" data-line-number="11">      <span class="dt">In</span> the expression<span class="fu">:</span> addMoney twoEuros dollar</a></code></pre></div>
+<div class="sourceCode" id="cb432"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb432-1" title="1"><span class="ot">addMoney ::</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency <span class="ot">-&gt;</span> <span class="dt">Money</span> currency</a>
+<a class="sourceLine" id="cb432-2" title="2">addMoney (<span class="dt">Money</span> a) (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a></code></pre></div>
+<div class="sourceCode" id="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb433-1" title="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney dollar dollar</a>
+<a class="sourceLine" id="cb433-2" title="2">addMoney dollar<span class="ot"> dollar ::</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb433-3" title="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney twoEuros twoEuros</a>
+<a class="sourceLine" id="cb433-4" title="4">addMoney twoEuros<span class="ot"> twoEuros ::</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb433-5" title="5"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> <span class="fu">:</span>t addMoney twoEuros dollar</a>
+<a class="sourceLine" id="cb433-6" title="6"><span class="fu">error:</span></a>
+<a class="sourceLine" id="cb433-7" title="7">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘<span class="dt">USD</span>’ with ‘<span class="dt">EUR</span>’</a>
+<a class="sourceLine" id="cb433-8" title="8">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb433-9" title="9">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb433-10" title="10">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘addMoney’, namely ‘dollar’</a>
+<a class="sourceLine" id="cb433-11" title="11">      <span class="dt">In</span> the expression<span class="fu">:</span> addMoney twoEuros dollar</a></code></pre></div>
 <p>As before, the type signature is crucial. Here’s the same implementation with an unrestricted type. Now we can add anything to anything!</p>
-<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb434-1" data-line-number="1"><span class="ot">addMoneyUnsafe ::</span> <span class="dt">Money</span> x <span class="ot">-&gt;</span> <span class="dt">Money</span> y <span class="ot">-&gt;</span> <span class="dt">Money</span> z</a>
-<a class="sourceLine" id="cb434-2" data-line-number="2">addMoneyUnsafe (<span class="dt">Money</span> a) (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a></code></pre></div>
-<div class="sourceCode" id="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb435-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> addMoneyUnsafe twoEuros dollar</a>
-<a class="sourceLine" id="cb435-2" data-line-number="2"><span class="dt">Money</span> <span class="fl">3.0</span></a></code></pre></div>
+<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb434-1" title="1"><span class="ot">addMoneyUnsafe ::</span> <span class="dt">Money</span> x <span class="ot">-&gt;</span> <span class="dt">Money</span> y <span class="ot">-&gt;</span> <span class="dt">Money</span> z</a>
+<a class="sourceLine" id="cb434-2" title="2">addMoneyUnsafe (<span class="dt">Money</span> a) (<span class="dt">Money</span> b) <span class="fu">=</span> <span class="dt">Money</span> (a<span class="fu">+</span>b)</a></code></pre></div>
+<div class="sourceCode" id="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb435-1" title="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> addMoneyUnsafe twoEuros dollar</a>
+<a class="sourceLine" id="cb435-2" title="2"><span class="dt">Money</span> <span class="fl">3.0</span></a></code></pre></div>
 <p>We can keep going with this approach, and define currency conversions. We define the type <code>Rate</code> that uses phantom types to track the currencies it’s translating between. The types of <code>convert</code> and <code>invert</code> are restricted to have the properties we want. There’s also an unrestricted version of the convert function to let you compare the types.</p>
-<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb436-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Rate</span> from to <span class="fu">=</span> <span class="dt">Rate</span> <span class="dt">Double</span></a>
-<a class="sourceLine" id="cb436-2" data-line-number="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
-<a class="sourceLine" id="cb436-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb436-4" data-line-number="4"><span class="ot">eurToUsd ::</span> <span class="dt">Rate</span> <span class="dt">EUR</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb436-5" data-line-number="5">eurToUsd <span class="fu">=</span> <span class="dt">Rate</span> <span class="fl">1.22</span></a>
-<a class="sourceLine" id="cb436-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb436-7" data-line-number="7"><span class="ot">convert ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Money</span> from <span class="ot">-&gt;</span> <span class="dt">Money</span> to</a>
-<a class="sourceLine" id="cb436-8" data-line-number="8">convert (<span class="dt">Rate</span> r) (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (r<span class="fu">*</span>a)</a>
-<a class="sourceLine" id="cb436-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb436-10" data-line-number="10"><span class="ot">invert ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Rate</span> to from</a>
-<a class="sourceLine" id="cb436-11" data-line-number="11">invert (<span class="dt">Rate</span> r) <span class="fu">=</span> <span class="dt">Rate</span> (<span class="dv">1</span><span class="fu">/</span>r)</a>
-<a class="sourceLine" id="cb436-12" data-line-number="12"></a>
-<a class="sourceLine" id="cb436-13" data-line-number="13"><span class="ot">convertUnsafe ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Money</span> x <span class="ot">-&gt;</span> <span class="dt">Money</span> y</a>
-<a class="sourceLine" id="cb436-14" data-line-number="14">convertUnsafe (<span class="dt">Rate</span> r) (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (r<span class="fu">*</span>a)</a></code></pre></div>
-<div class="sourceCode" id="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb437-1" data-line-number="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert eurToUsd twoEuros</a>
-<a class="sourceLine" id="cb437-2" data-line-number="2"><span class="dt">Money</span> <span class="fl">2.44</span></a>
-<a class="sourceLine" id="cb437-3" data-line-number="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert eurToUsd dollar</a>
-<a class="sourceLine" id="cb437-4" data-line-number="4">error<span class="fu">:</span></a>
-<a class="sourceLine" id="cb437-5" data-line-number="5">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘<span class="dt">USD</span>’ with ‘<span class="dt">EUR</span>’</a>
-<a class="sourceLine" id="cb437-6" data-line-number="6">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
-<a class="sourceLine" id="cb437-7" data-line-number="7">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
-<a class="sourceLine" id="cb437-8" data-line-number="8">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘convert’, namely ‘dollar’</a>
-<a class="sourceLine" id="cb437-9" data-line-number="9">      <span class="dt">In</span> the expression<span class="fu">:</span> convert eurToUsd dollar</a>
-<a class="sourceLine" id="cb437-10" data-line-number="10">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> convert eurToUsd dollar</a>
-<a class="sourceLine" id="cb437-11" data-line-number="11"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert (invert eurToUsd) dollar</a>
-<a class="sourceLine" id="cb437-12" data-line-number="12"><span class="dt">Money</span> <span class="fl">0.819672131147541</span></a>
-<a class="sourceLine" id="cb437-13" data-line-number="13"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convertUnsafe eurToUsd dollar</a>
-<a class="sourceLine" id="cb437-14" data-line-number="14"><span class="dt">Money</span> <span class="fl">1.22</span></a></code></pre></div>
+<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb436-1" title="1"><span class="kw">data</span> <span class="dt">Rate</span> from to <span class="fu">=</span> <span class="dt">Rate</span> <span class="dt">Double</span></a>
+<a class="sourceLine" id="cb436-2" title="2">  <span class="kw">deriving</span> <span class="dt">Show</span></a>
+<a class="sourceLine" id="cb436-3" title="3"></a>
+<a class="sourceLine" id="cb436-4" title="4"><span class="ot">eurToUsd ::</span> <span class="dt">Rate</span> <span class="dt">EUR</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb436-5" title="5">eurToUsd <span class="fu">=</span> <span class="dt">Rate</span> <span class="fl">1.22</span></a>
+<a class="sourceLine" id="cb436-6" title="6"></a>
+<a class="sourceLine" id="cb436-7" title="7"><span class="ot">convert ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Money</span> from <span class="ot">-&gt;</span> <span class="dt">Money</span> to</a>
+<a class="sourceLine" id="cb436-8" title="8">convert (<span class="dt">Rate</span> r) (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (r<span class="fu">*</span>a)</a>
+<a class="sourceLine" id="cb436-9" title="9"></a>
+<a class="sourceLine" id="cb436-10" title="10"><span class="ot">invert ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Rate</span> to from</a>
+<a class="sourceLine" id="cb436-11" title="11">invert (<span class="dt">Rate</span> r) <span class="fu">=</span> <span class="dt">Rate</span> (<span class="dv">1</span><span class="fu">/</span>r)</a>
+<a class="sourceLine" id="cb436-12" title="12"></a>
+<a class="sourceLine" id="cb436-13" title="13"><span class="ot">convertUnsafe ::</span> <span class="dt">Rate</span> from to <span class="ot">-&gt;</span> <span class="dt">Money</span> x <span class="ot">-&gt;</span> <span class="dt">Money</span> y</a>
+<a class="sourceLine" id="cb436-14" title="14">convertUnsafe (<span class="dt">Rate</span> r) (<span class="dt">Money</span> a) <span class="fu">=</span> <span class="dt">Money</span> (r<span class="fu">*</span>a)</a></code></pre></div>
+<div class="sourceCode" id="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb437-1" title="1"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert eurToUsd twoEuros</a>
+<a class="sourceLine" id="cb437-2" title="2"><span class="dt">Money</span> <span class="fl">2.44</span></a>
+<a class="sourceLine" id="cb437-3" title="3"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert eurToUsd dollar</a>
+<a class="sourceLine" id="cb437-4" title="4"><span class="fu">error:</span></a>
+<a class="sourceLine" id="cb437-5" title="5">    • <span class="dt">Couldn&#39;t</span> match <span class="kw">type</span> ‘<span class="dt">USD</span>’ with ‘<span class="dt">EUR</span>’</a>
+<a class="sourceLine" id="cb437-6" title="6">      <span class="dt">Expected</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">EUR</span></a>
+<a class="sourceLine" id="cb437-7" title="7">        <span class="dt">Actual</span> <span class="kw">type</span><span class="fu">:</span> <span class="dt">Money</span> <span class="dt">USD</span></a>
+<a class="sourceLine" id="cb437-8" title="8">    • <span class="dt">In</span> the second argument <span class="kw">of</span> ‘convert’, namely ‘dollar’</a>
+<a class="sourceLine" id="cb437-9" title="9">      <span class="dt">In</span> the expression<span class="fu">:</span> convert eurToUsd dollar</a>
+<a class="sourceLine" id="cb437-10" title="10">      <span class="dt">In</span> an equation for ‘it’<span class="fu">:</span> it <span class="fu">=</span> convert eurToUsd dollar</a>
+<a class="sourceLine" id="cb437-11" title="11"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convert (invert eurToUsd) dollar</a>
+<a class="sourceLine" id="cb437-12" title="12"><span class="dt">Money</span> <span class="fl">0.819672131147541</span></a>
+<a class="sourceLine" id="cb437-13" title="13"><span class="fu">*</span><span class="dt">Examples.Phantom</span><span class="fu">&gt;</span> convertUnsafe eurToUsd dollar</a>
+<a class="sourceLine" id="cb437-14" title="14"><span class="dt">Money</span> <span class="fl">1.22</span></a></code></pre></div>
 <p>Note! The words <code>currency</code>, <code>from</code>, <code>to</code> and so forth in the previous examples are <em>just type variables</em>. There’s nothing special going on with them. We could’ve as well given <code>invert</code> a type like <code>Rate a b -&gt; Rate b a</code> without any change in type safety.</p>
 <p>This approach that uses phantom types has clear benefits: giving us type errors for invalid code. Also, compared to defining lots of concrete types like <code>data MoneyEur = MoneyEur Double</code>, with phantom types we need to implement functions like <code>scaleMoney</code> and <code>addMoney</code> only once. Also, we’re able to define polymorphic and reusable concepts like <code>Rate</code>. You can contrast this approach with the Boxing section of Lecture 7.</p>
 <p>However, phantom types also have downsides. Without advanced tricks we can’t really handle currencies that are defined at runtime (for example: reading an amount from a user). It’s also easy to end up in a place where you start needing language extensions like <a href="https://wiki.haskell.org/GADTs_for_dummies"><em>Generalized Algebraic Datatypes</em></a>, <a href="https://wiki.haskell.org/GHC/Type_families"><em>type families</em></a> and other <a href="https://aphyr.com/posts/342-typing-the-technical-interview"><em>type-level programming</em></a> constructs. Eventually you’re all the way in the world of <a href="https://mitpress.mit.edu/books/little-typer"><em>dependent typing</em></a>.</p>
 <p>So what are good applications for phantom types? When you need to track some simple, but crucial information, that is known at compile-time. An example that’s somewhat better than currencies is tracking whether inputs from the user have been sanitated to prevent attacks like <a href="https://en.wikipedia.org/wiki/SQL_injection">SQL injection</a> or <a href="https://en.wikipedia.org/wiki/Cross-site_scripting">cross-site scripting</a>.</p>
 <p>We can use the types <code>Input Safe</code> and <code>Input Unsafe</code> to track whether strings are safe for passing into the database or not. If our module only exports the <code>makeInput</code> function, and not the <code>Input</code> constructor, the type system ensures that any inputs must pass through the <code>escapeInput</code> function at some point before going into a database function like <code>addForumComment</code>.</p>
-<div class="sourceCode" id="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb438-1" data-line-number="1"><span class="kw">data</span> <span class="dt">Safe</span></a>
-<a class="sourceLine" id="cb438-2" data-line-number="2"><span class="kw">data</span> <span class="dt">Unsafe</span></a>
-<a class="sourceLine" id="cb438-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb438-4" data-line-number="4"><span class="kw">data</span> <span class="dt">Input</span> a <span class="fu">=</span> <span class="dt">Input</span> <span class="dt">String</span></a>
-<a class="sourceLine" id="cb438-5" data-line-number="5"></a>
-<a class="sourceLine" id="cb438-6" data-line-number="6"><span class="co">-- Public constructor function for Input, only allows constructing</span></a>
-<a class="sourceLine" id="cb438-7" data-line-number="7"><span class="co">-- Unsafe Inputs from Strings.</span></a>
-<a class="sourceLine" id="cb438-8" data-line-number="8"><span class="ot">makeInput ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Input</span> <span class="dt">Unsafe</span></a>
-<a class="sourceLine" id="cb438-9" data-line-number="9">makeInput xs <span class="fu">=</span> <span class="dt">Input</span> xs</a>
-<a class="sourceLine" id="cb438-10" data-line-number="10"></a>
-<a class="sourceLine" id="cb438-11" data-line-number="11"><span class="co">-- Adds comment to the database.</span></a>
-<a class="sourceLine" id="cb438-12" data-line-number="12"><span class="ot">addForumComment ::</span> <span class="dt">Input</span> <span class="dt">Safe</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Result</span></a>
-<a class="sourceLine" id="cb438-13" data-line-number="13">addForumComment <span class="fu">=</span> <span class="fu">...</span></a>
-<a class="sourceLine" id="cb438-14" data-line-number="14"></a>
-<a class="sourceLine" id="cb438-15" data-line-number="15"><span class="co">-- We can combine inputs, but that won&#39;t change their safety</span></a>
-<a class="sourceLine" id="cb438-16" data-line-number="16"><span class="ot">concatInputs ::</span> <span class="dt">Input</span> a <span class="ot">-&gt;</span> <span class="dt">Input</span> a <span class="ot">-&gt;</span> <span class="dt">Input</span> a</a>
-<a class="sourceLine" id="cb438-17" data-line-number="17">concatInputs (<span class="dt">Input</span> xs) (<span class="dt">Input</span> ys) <span class="fu">=</span> <span class="dt">Input</span> (xs<span class="fu">++</span>ys)</a>
-<a class="sourceLine" id="cb438-18" data-line-number="18"></a>
-<a class="sourceLine" id="cb438-19" data-line-number="19"><span class="co">-- Strip bad characters to turn an unsafe input safe</span></a>
-<a class="sourceLine" id="cb438-20" data-line-number="20"><span class="ot">escapeInput ::</span> <span class="dt">Input</span> <span class="dt">Unsafe</span> <span class="ot">-&gt;</span> <span class="dt">Input</span> <span class="dt">Safe</span></a>
-<a class="sourceLine" id="cb438-21" data-line-number="21">escapeInput (<span class="dt">Input</span> xs) <span class="fu">=</span> <span class="dt">Input</span> (filter (\c <span class="ot">-&gt;</span> isAlpha c <span class="fu">||</span> isSpace c) xs)</a></code></pre></div>
+<div class="sourceCode" id="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb438-1" title="1"><span class="kw">data</span> <span class="dt">Safe</span></a>
+<a class="sourceLine" id="cb438-2" title="2"><span class="kw">data</span> <span class="dt">Unsafe</span></a>
+<a class="sourceLine" id="cb438-3" title="3"></a>
+<a class="sourceLine" id="cb438-4" title="4"><span class="kw">data</span> <span class="dt">Input</span> a <span class="fu">=</span> <span class="dt">Input</span> <span class="dt">String</span></a>
+<a class="sourceLine" id="cb438-5" title="5"></a>
+<a class="sourceLine" id="cb438-6" title="6"><span class="co">-- Public constructor function for Input, only allows constructing</span></a>
+<a class="sourceLine" id="cb438-7" title="7"><span class="co">-- Unsafe Inputs from Strings.</span></a>
+<a class="sourceLine" id="cb438-8" title="8"><span class="ot">makeInput ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">Input</span> <span class="dt">Unsafe</span></a>
+<a class="sourceLine" id="cb438-9" title="9">makeInput xs <span class="fu">=</span> <span class="dt">Input</span> xs</a>
+<a class="sourceLine" id="cb438-10" title="10"></a>
+<a class="sourceLine" id="cb438-11" title="11"><span class="co">-- Adds comment to the database.</span></a>
+<a class="sourceLine" id="cb438-12" title="12"><span class="ot">addForumComment ::</span> <span class="dt">Input</span> <span class="dt">Safe</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> <span class="dt">Result</span></a>
+<a class="sourceLine" id="cb438-13" title="13">addForumComment <span class="fu">=</span> <span class="fu">...</span></a>
+<a class="sourceLine" id="cb438-14" title="14"></a>
+<a class="sourceLine" id="cb438-15" title="15"><span class="co">-- We can combine inputs, but that won&#39;t change their safety</span></a>
+<a class="sourceLine" id="cb438-16" title="16"><span class="ot">concatInputs ::</span> <span class="dt">Input</span> a <span class="ot">-&gt;</span> <span class="dt">Input</span> a <span class="ot">-&gt;</span> <span class="dt">Input</span> a</a>
+<a class="sourceLine" id="cb438-17" title="17">concatInputs (<span class="dt">Input</span> xs) (<span class="dt">Input</span> ys) <span class="fu">=</span> <span class="dt">Input</span> (xs<span class="fu">++</span>ys)</a>
+<a class="sourceLine" id="cb438-18" title="18"></a>
+<a class="sourceLine" id="cb438-19" title="19"><span class="co">-- Strip bad characters to turn an unsafe input safe</span></a>
+<a class="sourceLine" id="cb438-20" title="20"><span class="ot">escapeInput ::</span> <span class="dt">Input</span> <span class="dt">Unsafe</span> <span class="ot">-&gt;</span> <span class="dt">Input</span> <span class="dt">Safe</span></a>
+<a class="sourceLine" id="cb438-21" title="21">escapeInput (<span class="dt">Input</span> xs) <span class="fu">=</span> <span class="dt">Input</span> (<span class="fu">filter</span> (\c <span class="ot">-&gt;</span> <span class="fu">isAlpha</span> c <span class="fu">||</span> <span class="fu">isSpace</span> c) xs)</a></code></pre></div>
 <h2 id="simultaneity"><span class="header-section-number">16.3</span> Simultaneity</h2>
 <h3 id="parallelism"><span class="header-section-number">16.3.1</span> Parallelism</h3>
 <p>One of the great things about purity is that it makes <em>parallelism</em>, computing many things at the same time, very easy. Let’s have a look at how we can do this in Haskell. First off, we need to start a new GHCi that has parallel execution enabled. The simplest way is:</p>
 <pre><code>$ stack ghci --ghci-options &quot;+RTS -N&quot;</code></pre>
 <p>Next up, let’s define a very naive version of the Fibonacci function (remember Lecture 1?) , enable performance statistics with <code>:set +s</code>, and see how long it takes to compute five values of the function:</p>
-<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb440-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> fib <span class="dv">0</span> <span class="fu">=</span> <span class="dv">1</span>; fib <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span>; fib n <span class="fu">=</span> fib (n<span class="fu">-</span><span class="dv">1</span>) <span class="fu">+</span> fib (n<span class="fu">-</span><span class="dv">2</span>)</a>
-<a class="sourceLine" id="cb440-2" data-line-number="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>set <span class="fu">+</span>s</a>
-<a class="sourceLine" id="cb440-3" data-line-number="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> map fib [<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>]</a>
-<a class="sourceLine" id="cb440-4" data-line-number="4">[<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>]</a>
-<a class="sourceLine" id="cb440-5" data-line-number="5">(<span class="fl">7.54</span> secs, <span class="dv">2</span>,<span class="dv">440</span>,<span class="dv">860</span>,<span class="dv">632</span> bytes)</a></code></pre></div>
+<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb440-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> fib <span class="dv">0</span> <span class="fu">=</span> <span class="dv">1</span>; fib <span class="dv">1</span> <span class="fu">=</span> <span class="dv">1</span>; fib n <span class="fu">=</span> fib (n<span class="fu">-</span><span class="dv">1</span>) <span class="fu">+</span> fib (n<span class="fu">-</span><span class="dv">2</span>)</a>
+<a class="sourceLine" id="cb440-2" title="2"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">:</span>set <span class="fu">+</span>s</a>
+<a class="sourceLine" id="cb440-3" title="3"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="fu">map</span> fib [<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>]</a>
+<a class="sourceLine" id="cb440-4" title="4">[<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>]</a>
+<a class="sourceLine" id="cb440-5" title="5">(<span class="fl">7.54</span> secs, <span class="dv">2</span>,<span class="dv">440</span>,<span class="dv">860</span>,<span class="dv">632</span> bytes)</a></code></pre></div>
 <p>Now let’s bring in the module <a href="https://hackage.haskell.org/package/parallel-3.2.1.1/docs/Control-Parallel-Strategies.html">Control.Parallel.Strategies</a> that defines ways to evaluate values in parallel. We’ll use the <code>parList rseq</code> strategy to evaluate all the elements of the list to WHNF, <em>in parallel</em>.</p>
-<div class="sourceCode" id="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb441-1" data-line-number="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Control.Parallel.Strategies</span></a>
-<a class="sourceLine" id="cb441-2" data-line-number="2"><span class="dt">Prelude</span> <span class="dt">Control.Parallel.Strategies</span><span class="fu">&gt;</span> withStrategy (parList rseq) (map fib [<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>])</a>
-<a class="sourceLine" id="cb441-3" data-line-number="3">[<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>]</a>
-<a class="sourceLine" id="cb441-4" data-line-number="4">(<span class="fl">4.80</span> secs, <span class="dv">488</span>,<span class="dv">531</span>,<span class="dv">384</span> bytes)</a></code></pre></div>
+<div class="sourceCode" id="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb441-1" title="1"><span class="dt">Prelude</span><span class="fu">&gt;</span> <span class="kw">import</span> <span class="dt">Control.Parallel.Strategies</span></a>
+<a class="sourceLine" id="cb441-2" title="2"><span class="dt">Prelude</span> <span class="dt">Control.Parallel.Strategies</span><span class="fu">&gt;</span> withStrategy (parList rseq) (<span class="fu">map</span> fib [<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>,<span class="dv">29</span>])</a>
+<a class="sourceLine" id="cb441-3" title="3">[<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>,<span class="dv">832040</span>]</a>
+<a class="sourceLine" id="cb441-4" title="4">(<span class="fl">4.80</span> secs, <span class="dv">488</span>,<span class="dv">531</span>,<span class="dv">384</span> bytes)</a></code></pre></div>
 <p>That’s almost 2 times as fast, on the 2-core machine that this example is being run on. Pretty nice. The coolest thing here is that we were able to define the <em>computation</em> (<code>map fib ...</code>) completely separately from the <em>evaluation strategy</em> (<code>parList rseq</code>), separating the <em>what to compute</em> from the <em>how to compute</em>.</p>
 <h3 id="concurrency"><span class="header-section-number">16.3.2</span> Concurrency</h3>
 <p>Computer science makes the distinction between parallel and <em>concurrent</em> computations. Parallel computations are those that just run separate independent computations in parallel (in other words, parallelism is <em>pure</em>). Concurrent computations are those where there are multiple interacting threads of computation. Concurrency usually involves threads, locks, messages and deadlocks.</p>
 <p>In addition to great tooling for parallelism, Haskell also has good tooling for concurrency via <em>threads</em>. Since concurrency is all about side-effects, concurrent computations happen in the <code>IO</code> Monad. The classic example of threading is two threads, one printing a stream of As and the other a stream of Bs. Here it is in Haskell:</p>
-<div class="sourceCode" id="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb442-1" data-line-number="1"><span class="ot">printA ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb442-2" data-line-number="2">printA <span class="fu">=</span> putStrLn (replicate <span class="dv">40</span> <span class="ch">&#39;A&#39;</span>)</a>
-<a class="sourceLine" id="cb442-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb442-4" data-line-number="4"><span class="ot">printB ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb442-5" data-line-number="5">printB <span class="fu">=</span> putStrLn (replicate <span class="dv">40</span> <span class="ch">&#39;B&#39;</span>)</a>
-<a class="sourceLine" id="cb442-6" data-line-number="6"></a>
-<a class="sourceLine" id="cb442-7" data-line-number="7"><span class="ot">concurrency ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb442-8" data-line-number="8">concurrency <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb442-9" data-line-number="9">  forkIO printA</a>
-<a class="sourceLine" id="cb442-10" data-line-number="10">  forkIO printB</a>
-<a class="sourceLine" id="cb442-11" data-line-number="11">  return ()</a></code></pre></div>
+<div class="sourceCode" id="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb442-1" title="1"><span class="ot">printA ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb442-2" title="2">printA <span class="fu">=</span> <span class="fu">putStrLn</span> (<span class="fu">replicate</span> <span class="dv">40</span> <span class="ch">&#39;A&#39;</span>)</a>
+<a class="sourceLine" id="cb442-3" title="3"></a>
+<a class="sourceLine" id="cb442-4" title="4"><span class="ot">printB ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb442-5" title="5">printB <span class="fu">=</span> <span class="fu">putStrLn</span> (<span class="fu">replicate</span> <span class="dv">40</span> <span class="ch">&#39;B&#39;</span>)</a>
+<a class="sourceLine" id="cb442-6" title="6"></a>
+<a class="sourceLine" id="cb442-7" title="7"><span class="ot">concurrency ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb442-8" title="8">concurrency <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb442-9" title="9">  forkIO printA</a>
+<a class="sourceLine" id="cb442-10" title="10">  forkIO printB</a>
+<a class="sourceLine" id="cb442-11" title="11">  <span class="fu">return</span> ()</a></code></pre></div>
 <pre><code>Prelude Control.Concurrent&gt; concurrency
 AABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABB</code></pre>
 <p>The operation <code>forkIO :: IO () -&gt; IO ThreadId</code> takes an IO operation and starts running it in the backgroud. It produces a <code>ThreadId</code> that can be used to e.g. terminate the thread.</p>
 <p>If we want to add actual communication between threads, we can use abstractions like <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Control-Concurrent-MVar.html"><code>MVar</code></a> (a mutable thread-safe variable) or <a href="https://hackage.haskell.org/package/base-4.14.1.0/docs/Control-Concurrent-Chan.html"><code>Chan</code></a> (a queue).</p>
 <p>Here’s a simple example where one thread writes a value to an <code>MVar</code> and another one waits for them and prints them. An <code>MVar</code> works like a mailbox: it is either empty or full. Calling <code>takeMVar</code> on an empty box waits for the box to get filled (with a <code>putMVar</code>). Symmetrically, trying to <code>putMVar</code> into a full box waits until the box is empty.</p>
-<div class="sourceCode" id="cb444"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb444-1" data-line-number="1"><span class="ot">takeMVar ::</span> <span class="dt">MVar</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> a</a>
-<a class="sourceLine" id="cb444-2" data-line-number="2"><span class="ot">putMVar ::</span> <span class="dt">MVar</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb444-3" data-line-number="3"><span class="ot">newEmptyMVar ::</span> <span class="dt">IO</span> (<span class="dt">MVar</span> a)</a></code></pre></div>
-<div class="sourceCode" id="cb445"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb445-1" data-line-number="1"><span class="ot">send ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">MVar</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb445-2" data-line-number="2">send values var <span class="fu">=</span> mapM_ (putMVar var) values</a>
-<a class="sourceLine" id="cb445-3" data-line-number="3"></a>
-<a class="sourceLine" id="cb445-4" data-line-number="4"><span class="ot">receive ::</span> <span class="dt">MVar</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb445-5" data-line-number="5">receive var <span class="fu">=</span> <span class="kw">do</span> val <span class="ot">&lt;-</span> takeMVar var</a>
-<a class="sourceLine" id="cb445-6" data-line-number="6">                 print val</a>
-<a class="sourceLine" id="cb445-7" data-line-number="7">                 <span class="co">-- loop unless at last value</span></a>
-<a class="sourceLine" id="cb445-8" data-line-number="8">                 when (val<span class="fu">/=</span><span class="st">&quot;end&quot;</span>) (receive var)</a>
-<a class="sourceLine" id="cb445-9" data-line-number="9"></a>
-<a class="sourceLine" id="cb445-10" data-line-number="10"><span class="ot">concurrency2 ::</span> <span class="dt">IO</span> ()</a>
-<a class="sourceLine" id="cb445-11" data-line-number="11">concurrency2 <span class="fu">=</span> <span class="kw">do</span></a>
-<a class="sourceLine" id="cb445-12" data-line-number="12">  var <span class="ot">&lt;-</span> newEmptyMVar</a>
-<a class="sourceLine" id="cb445-13" data-line-number="13">  forkIO (send [<span class="st">&quot;hello&quot;</span>,<span class="st">&quot;world&quot;</span>,<span class="st">&quot;and&quot;</span>,<span class="st">&quot;goodbye&quot;</span>,<span class="st">&quot;end&quot;</span>] var)</a>
-<a class="sourceLine" id="cb445-14" data-line-number="14">  forkIO (receive var)</a>
-<a class="sourceLine" id="cb445-15" data-line-number="15">  return ()</a></code></pre></div>
-<div class="sourceCode" id="cb446"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb446-1" data-line-number="1"><span class="dt">Prelude</span> <span class="dt">Control.Concurrent</span> <span class="dt">Control.Monad</span><span class="fu">&gt;</span> concurrency2</a>
-<a class="sourceLine" id="cb446-2" data-line-number="2"><span class="st">&quot;hello&quot;</span></a>
-<a class="sourceLine" id="cb446-3" data-line-number="3"><span class="st">&quot;world&quot;</span></a>
-<a class="sourceLine" id="cb446-4" data-line-number="4"><span class="st">&quot;and&quot;</span></a>
-<a class="sourceLine" id="cb446-5" data-line-number="5"><span class="st">&quot;goodbye&quot;</span></a>
-<a class="sourceLine" id="cb446-6" data-line-number="6"><span class="st">&quot;end&quot;</span></a></code></pre></div>
+<div class="sourceCode" id="cb444"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb444-1" title="1"><span class="ot">takeMVar ::</span> <span class="dt">MVar</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> a</a>
+<a class="sourceLine" id="cb444-2" title="2"><span class="ot">putMVar ::</span> <span class="dt">MVar</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb444-3" title="3"><span class="ot">newEmptyMVar ::</span> <span class="dt">IO</span> (<span class="dt">MVar</span> a)</a></code></pre></div>
+<div class="sourceCode" id="cb445"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb445-1" title="1"><span class="ot">send ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">MVar</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb445-2" title="2">send values var <span class="fu">=</span> <span class="fu">mapM_</span> (putMVar var) values</a>
+<a class="sourceLine" id="cb445-3" title="3"></a>
+<a class="sourceLine" id="cb445-4" title="4"><span class="ot">receive ::</span> <span class="dt">MVar</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb445-5" title="5">receive var <span class="fu">=</span> <span class="kw">do</span> val <span class="ot">&lt;-</span> takeMVar var</a>
+<a class="sourceLine" id="cb445-6" title="6">                 <span class="fu">print</span> val</a>
+<a class="sourceLine" id="cb445-7" title="7">                 <span class="co">-- loop unless at last value</span></a>
+<a class="sourceLine" id="cb445-8" title="8">                 when (val<span class="fu">/=</span><span class="st">&quot;end&quot;</span>) (receive var)</a>
+<a class="sourceLine" id="cb445-9" title="9"></a>
+<a class="sourceLine" id="cb445-10" title="10"><span class="ot">concurrency2 ::</span> <span class="dt">IO</span> ()</a>
+<a class="sourceLine" id="cb445-11" title="11">concurrency2 <span class="fu">=</span> <span class="kw">do</span></a>
+<a class="sourceLine" id="cb445-12" title="12">  var <span class="ot">&lt;-</span> newEmptyMVar</a>
+<a class="sourceLine" id="cb445-13" title="13">  forkIO (send [<span class="st">&quot;hello&quot;</span>,<span class="st">&quot;world&quot;</span>,<span class="st">&quot;and&quot;</span>,<span class="st">&quot;goodbye&quot;</span>,<span class="st">&quot;end&quot;</span>] var)</a>
+<a class="sourceLine" id="cb445-14" title="14">  forkIO (receive var)</a>
+<a class="sourceLine" id="cb445-15" title="15">  <span class="fu">return</span> ()</a></code></pre></div>
+<div class="sourceCode" id="cb446"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb446-1" title="1"><span class="dt">Prelude</span> <span class="dt">Control.Concurrent</span> <span class="dt">Control.Monad</span><span class="fu">&gt;</span> concurrency2</a>
+<a class="sourceLine" id="cb446-2" title="2"><span class="st">&quot;hello&quot;</span></a>
+<a class="sourceLine" id="cb446-3" title="3"><span class="st">&quot;world&quot;</span></a>
+<a class="sourceLine" id="cb446-4" title="4"><span class="st">&quot;and&quot;</span></a>
+<a class="sourceLine" id="cb446-5" title="5"><span class="st">&quot;goodbye&quot;</span></a>
+<a class="sourceLine" id="cb446-6" title="6"><span class="st">&quot;end&quot;</span></a></code></pre></div>
 <h2 id="exercises-7"><span class="header-section-number">16.4</span> Exercises</h2>
 <ul>
 <li><a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Set16a.hs">Set16a</a>: QuickCheck</li>