From 8d9f004ed50cc5ff6f6674698ba6ddc2e2e95494 Mon Sep 17 00:00:00 2001
From: Joel Kaasinen <joel.kaasinen@metosin.fi>
Date: Tue, 14 May 2024 09:04:21 +0300
Subject: [PATCH] lecture 6: remove sidenote about instance restrictions

GHC now enables FlexibleInstances by default
---
 part1.html | 933 ++++++++++++++++++++++++++---------------------------
 1 file changed, 455 insertions(+), 478 deletions(-)

diff --git a/part1.html b/part1.html
index ee92b72..655f919 100644
--- a/part1.html
+++ b/part1.html
@@ -160,12 +160,11 @@ code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warni
 <li><a href="#lecture-6-working-class-hero"><span class="toc-section-number">6</span> Lecture 6: Working Class Hero</a>
 <ul>
 <li><a href="#syntax-of-classes-and-instances"><span class="toc-section-number">6.1</span> Syntax of Classes and Instances</a></li>
-<li><a href="#sidenote-restrictions-on-instances"><span class="toc-section-number">6.2</span> Sidenote: Restrictions on Instances</a></li>
-<li><a href="#default-implementations"><span class="toc-section-number">6.3</span> Default Implementations</a></li>
-<li><a href="#useful-stuff"><span class="toc-section-number">6.4</span> Useful Stuff</a></li>
-<li><a href="#hierarchies"><span class="toc-section-number">6.5</span> Hierarchies</a></li>
-<li><a href="#quiz-5"><span class="toc-section-number">6.6</span> Quiz</a></li>
-<li><a href="#exercises-5"><span class="toc-section-number">6.7</span> Exercises</a></li>
+<li><a href="#default-implementations"><span class="toc-section-number">6.2</span> Default Implementations</a></li>
+<li><a href="#useful-stuff"><span class="toc-section-number">6.3</span> Useful Stuff</a></li>
+<li><a href="#hierarchies"><span class="toc-section-number">6.4</span> Hierarchies</a></li>
+<li><a href="#quiz-5"><span class="toc-section-number">6.5</span> Quiz</a></li>
+<li><a href="#exercises-5"><span class="toc-section-number">6.6</span> Exercises</a></li>
 </ul></li>
 <li><a href="#lecture-7-new-constellations"><span class="toc-section-number">7</span> Lecture 7: New Constellations</a>
 <ul>
@@ -3385,215 +3384,193 @@ Because <code>Nothing</code> is a constructor.
 <span id="cb381-15"><a href="#cb381-15" aria-hidden="true" tabindex="-1"></a>  empty <span class="ot">=</span> []</span>
 <span id="cb381-16"><a href="#cb381-16" aria-hidden="true" tabindex="-1"></a>  size xs <span class="ot">=</span> <span class="fu">length</span> xs</span>
 <span id="cb381-17"><a href="#cb381-17" aria-hidden="true" tabindex="-1"></a>  sameSize x y <span class="ot">=</span> size x <span class="op">==</span> size y</span></code></pre></div>
-<h2 data-number="6.2" 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="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb382-1"><a href="#cb382-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></span>
-<span id="cb382-2"><a href="#cb382-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></span></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="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb383-1"><a href="#cb383-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Size</span> [<span class="dt">Bool</span>] <span class="kw">where</span></span>
-<span id="cb383-2"><a href="#cb383-2" aria-hidden="true" tabindex="-1"></a>  size bs <span class="ot">=</span> <span class="fu">length</span> (<span class="fu">filter</span> <span class="fu">id</span> bs)   <span class="co">-- count Trues</span></span></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)
-         where a1 ... an are *distinct type variables*,
-         and each type variable appears at most once in the instance head.
-         Use FlexibleInstances if you want to disable this.)
-    • In the instance declaration for ‘Size [Bool]’</code></pre>
-<p>Dang. As the error tries to tell us, we can only define instances where all type parameters are <em>different</em> type variables. That is, we can define <code>instance Size (Either a b)</code> but we can’t define:</p>
-<ul>
-<li><code>instance Size (Either String a)</code> – since <code>String</code> is not a type variable</li>
-<li><code>instance Size (Either a a)</code> – since the type variables aren’t different</li>
-<li><code>instance Size [[a]]</code> – since <code>[a]</code> is not a type variable</li>
-</ul>
-<p>Why is this? This rule guarantees that it’s simple for the compiler to look up the correct type class instance. It can just look at what the <em>top-level type constructor</em> is, and then pick an instance.</p>
-<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 data-number="6.3" id="default-implementations"><span class="header-section-number">6.3</span> Default Implementations</h2>
+<h2 data-number="6.2" id="default-implementations"><span class="header-section-number">6.2</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="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb385-1"><a href="#cb385-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Example</span> a <span class="kw">where</span></span>
-<span id="cb385-2"><a href="#cb385-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  example ::</span> a           <span class="co">-- the main example for the type `a`</span></span>
-<span id="cb385-3"><a href="#cb385-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  examples ::</span> [a]        <span class="co">-- a short list of examples</span></span>
-<span id="cb385-4"><a href="#cb385-4" aria-hidden="true" tabindex="-1"></a>  examples <span class="ot">=</span> [example]   <span class="co">-- ...defaulting to just the main example</span></span>
-<span id="cb385-5"><a href="#cb385-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb385-6"><a href="#cb385-6" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Int</span> <span class="kw">where</span></span>
-<span id="cb385-7"><a href="#cb385-7" aria-hidden="true" tabindex="-1"></a>  example <span class="ot">=</span> <span class="dv">1</span></span>
-<span id="cb385-8"><a href="#cb385-8" aria-hidden="true" tabindex="-1"></a>  examples <span class="ot">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</span>
-<span id="cb385-9"><a href="#cb385-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb385-10"><a href="#cb385-10" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Bool</span> <span class="kw">where</span></span>
-<span id="cb385-11"><a href="#cb385-11" aria-hidden="true" tabindex="-1"></a>  example <span class="ot">=</span> <span class="dt">True</span></span></code></pre></div>
+<div class="sourceCode" id="cb382"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb382-1"><a href="#cb382-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Example</span> a <span class="kw">where</span></span>
+<span id="cb382-2"><a href="#cb382-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  example ::</span> a           <span class="co">-- the main example for the type `a`</span></span>
+<span id="cb382-3"><a href="#cb382-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  examples ::</span> [a]        <span class="co">-- a short list of examples</span></span>
+<span id="cb382-4"><a href="#cb382-4" aria-hidden="true" tabindex="-1"></a>  examples <span class="ot">=</span> [example]   <span class="co">-- ...defaulting to just the main example</span></span>
+<span id="cb382-5"><a href="#cb382-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb382-6"><a href="#cb382-6" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Int</span> <span class="kw">where</span></span>
+<span id="cb382-7"><a href="#cb382-7" aria-hidden="true" tabindex="-1"></a>  example <span class="ot">=</span> <span class="dv">1</span></span>
+<span id="cb382-8"><a href="#cb382-8" aria-hidden="true" tabindex="-1"></a>  examples <span class="ot">=</span> [<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</span>
+<span id="cb382-9"><a href="#cb382-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb382-10"><a href="#cb382-10" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Example</span> <span class="dt">Bool</span> <span class="kw">where</span></span>
+<span id="cb382-11"><a href="#cb382-11" aria-hidden="true" tabindex="-1"></a>  example <span class="ot">=</span> <span class="dt">True</span></span></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="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb386-1"><a href="#cb386-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> example ::</span> <span class="dt">Bool</span></span>
-<span id="cb386-2"><a href="#cb386-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
-<span id="cb386-3"><a href="#cb386-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> example ::</span> <span class="dt">Int</span></span>
-<span id="cb386-4"><a href="#cb386-4" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span></span>
-<span id="cb386-5"><a href="#cb386-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Bool</span>]</span>
-<span id="cb386-6"><a href="#cb386-6" aria-hidden="true" tabindex="-1"></a>[<span class="dt">True</span>]</span>
-<span id="cb386-7"><a href="#cb386-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Int</span>]</span>
-<span id="cb386-8"><a href="#cb386-8" aria-hidden="true" tabindex="-1"></a>[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb383"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb383-1"><a href="#cb383-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> example ::</span> <span class="dt">Bool</span></span>
+<span id="cb383-2"><a href="#cb383-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb383-3"><a href="#cb383-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> example ::</span> <span class="dt">Int</span></span>
+<span id="cb383-4"><a href="#cb383-4" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span></span>
+<span id="cb383-5"><a href="#cb383-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Bool</span>]</span>
+<span id="cb383-6"><a href="#cb383-6" aria-hidden="true" tabindex="-1"></a>[<span class="dt">True</span>]</span>
+<span id="cb383-7"><a href="#cb383-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span><span class="ot"> examples ::</span> [<span class="dt">Int</span>]</span>
+<span id="cb383-8"><a href="#cb383-8" aria-hidden="true" tabindex="-1"></a>[<span class="dv">0</span>,<span class="dv">1</span>,<span class="dv">2</span>]</span></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="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb387-1"><a href="#cb387-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></span>
-<span id="cb387-2"><a href="#cb387-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  (==) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
-<span id="cb387-3"><a href="#cb387-3" aria-hidden="true" tabindex="-1"></a>  x <span class="op">==</span> y  <span class="ot">=</span> <span class="fu">not</span> (x <span class="op">/=</span> y)</span>
-<span id="cb387-4"><a href="#cb387-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb387-5"><a href="#cb387-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  (/=) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
-<span id="cb387-6"><a href="#cb387-6" aria-hidden="true" tabindex="-1"></a>  x <span class="op">/=</span> y  <span class="ot">=</span> <span class="fu">not</span> (x <span class="op">==</span> y)</span></code></pre></div>
+<div class="sourceCode" id="cb384"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb384-1"><a href="#cb384-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Eq</span> a <span class="kw">where</span></span>
+<span id="cb384-2"><a href="#cb384-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  (==) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
+<span id="cb384-3"><a href="#cb384-3" aria-hidden="true" tabindex="-1"></a>  x <span class="op">==</span> y  <span class="ot">=</span> <span class="fu">not</span> (x <span class="op">/=</span> y)</span>
+<span id="cb384-4"><a href="#cb384-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb384-5"><a href="#cb384-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  (/=) ::</span>  a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
+<span id="cb384-6"><a href="#cb384-6" aria-hidden="true" tabindex="-1"></a>  x <span class="op">/=</span> y  <span class="ot">=</span> <span class="fu">not</span> (x <span class="op">==</span> y)</span></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.16.4.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="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb388-1"><a href="#cb388-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb388-2"><a href="#cb388-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  compare              ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></span>
-<span id="cb388-3"><a href="#cb388-3" aria-hidden="true" tabindex="-1"></a>  (<span class="op">&lt;</span>), (<span class="op">&lt;=</span>), (<span class="op">&gt;=</span>),<span class="ot"> (&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
-<span id="cb388-4"><a href="#cb388-4" aria-hidden="true" tabindex="-1"></a>  <span class="fu">max</span>,<span class="ot"> min             ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb388-5"><a href="#cb388-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb388-6"><a href="#cb388-6" aria-hidden="true" tabindex="-1"></a>  <span class="fu">compare</span> x y <span class="op">|</span> x <span class="op">==</span> y    <span class="ot">=</span> <span class="dt">EQ</span></span>
-<span id="cb388-7"><a href="#cb388-7" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span> <span class="dt">LT</span></span>
-<span id="cb388-8"><a href="#cb388-8" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span> <span class="dt">GT</span></span>
-<span id="cb388-9"><a href="#cb388-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb388-10"><a href="#cb388-10" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;=</span> y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">/=</span> <span class="dt">GT</span></span>
-<span id="cb388-11"><a href="#cb388-11" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;</span>  y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">==</span> <span class="dt">LT</span></span>
-<span id="cb388-12"><a href="#cb388-12" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&gt;=</span> y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">/=</span> <span class="dt">LT</span></span>
-<span id="cb388-13"><a href="#cb388-13" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&gt;</span>  y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">==</span> <span class="dt">GT</span></span>
-<span id="cb388-14"><a href="#cb388-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb388-15"><a href="#cb388-15" aria-hidden="true" tabindex="-1"></a>  <span class="fu">max</span> x y <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span>  y</span>
-<span id="cb388-16"><a href="#cb388-16" aria-hidden="true" tabindex="-1"></a>          <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span>  x</span>
-<span id="cb388-17"><a href="#cb388-17" aria-hidden="true" tabindex="-1"></a>  <span class="fu">min</span> x y <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span>  x</span>
-<span id="cb388-18"><a href="#cb388-18" aria-hidden="true" tabindex="-1"></a>          <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span>  y</span></code></pre></div>
+<div class="sourceCode" id="cb385"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb385-1"><a href="#cb385-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb385-2"><a href="#cb385-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  compare              ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Ordering</span></span>
+<span id="cb385-3"><a href="#cb385-3" aria-hidden="true" tabindex="-1"></a>  (<span class="op">&lt;</span>), (<span class="op">&lt;=</span>), (<span class="op">&gt;=</span>),<span class="ot"> (&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
+<span id="cb385-4"><a href="#cb385-4" aria-hidden="true" tabindex="-1"></a>  <span class="fu">max</span>,<span class="ot"> min             ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb385-5"><a href="#cb385-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb385-6"><a href="#cb385-6" aria-hidden="true" tabindex="-1"></a>  <span class="fu">compare</span> x y <span class="op">|</span> x <span class="op">==</span> y    <span class="ot">=</span> <span class="dt">EQ</span></span>
+<span id="cb385-7"><a href="#cb385-7" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span> <span class="dt">LT</span></span>
+<span id="cb385-8"><a href="#cb385-8" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span> <span class="dt">GT</span></span>
+<span id="cb385-9"><a href="#cb385-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb385-10"><a href="#cb385-10" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;=</span> y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">/=</span> <span class="dt">GT</span></span>
+<span id="cb385-11"><a href="#cb385-11" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;</span>  y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">==</span> <span class="dt">LT</span></span>
+<span id="cb385-12"><a href="#cb385-12" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&gt;=</span> y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">/=</span> <span class="dt">LT</span></span>
+<span id="cb385-13"><a href="#cb385-13" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&gt;</span>  y  <span class="ot">=</span> <span class="fu">compare</span> x y <span class="op">==</span> <span class="dt">GT</span></span>
+<span id="cb385-14"><a href="#cb385-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb385-15"><a href="#cb385-15" aria-hidden="true" tabindex="-1"></a>  <span class="fu">max</span> x y <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span>  y</span>
+<span id="cb385-16"><a href="#cb385-16" aria-hidden="true" tabindex="-1"></a>          <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span>  x</span>
+<span id="cb385-17"><a href="#cb385-17" aria-hidden="true" tabindex="-1"></a>  <span class="fu">min</span> x y <span class="op">|</span> x <span class="op">&lt;=</span> y    <span class="ot">=</span>  x</span>
+<span id="cb385-18"><a href="#cb385-18" aria-hidden="true" tabindex="-1"></a>          <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span>  y</span></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.16.4.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="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb389-1"><a href="#cb389-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></span>
-<span id="cb389-2"><a href="#cb389-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb389-3"><a href="#cb389-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine3 ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb389-4"><a href="#cb389-4" aria-hidden="true" tabindex="-1"></a>  combine3 x y z <span class="ot">=</span> combine x (combine y z)</span></code></pre></div>
+<div class="sourceCode" id="cb386"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb386-1"><a href="#cb386-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></span>
+<span id="cb386-2"><a href="#cb386-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb386-3"><a href="#cb386-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine3 ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb386-4"><a href="#cb386-4" aria-hidden="true" tabindex="-1"></a>  combine3 x y z <span class="ot">=</span> combine x (combine y z)</span></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="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb390-1"><a href="#cb390-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></span>
-<span id="cb390-2"><a href="#cb390-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb390-3"><a href="#cb390-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb390-4"><a href="#cb390-4" aria-hidden="true" tabindex="-1"></a><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</span>
-<span id="cb390-5"><a href="#cb390-5" aria-hidden="true" tabindex="-1"></a>combine3 x y z <span class="ot">=</span> combine x (combine y z)</span></code></pre></div>
+<div class="sourceCode" id="cb387"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb387-1"><a href="#cb387-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Combine</span> a <span class="kw">where</span></span>
+<span id="cb387-2"><a href="#cb387-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  combine ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb387-3"><a href="#cb387-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb387-4"><a href="#cb387-4" aria-hidden="true" tabindex="-1"></a><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</span>
+<span id="cb387-5"><a href="#cb387-5" aria-hidden="true" tabindex="-1"></a>combine3 x y z <span class="ot">=</span> combine x (combine y z)</span></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="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb391-1"><a href="#cb391-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">IntPair</span> <span class="ot">=</span> <span class="dt">IntPair</span> <span class="dt">Int</span> <span class="dt">Int</span></span>
-<span id="cb391-2"><a href="#cb391-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
-<span id="cb391-3"><a href="#cb391-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb391-4"><a href="#cb391-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntPair</span> <span class="kw">where</span></span>
-<span id="cb391-5"><a href="#cb391-5" aria-hidden="true" tabindex="-1"></a>  <span class="dt">IntPair</span> a1 a2 <span class="op">==</span> <span class="dt">IntPair</span> b1 b2  <span class="ot">=</span>  a1<span class="op">==</span>b1 <span class="op">&amp;&amp;</span> a2<span class="op">==</span>b2</span>
-<span id="cb391-6"><a href="#cb391-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb391-7"><a href="#cb391-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">IntPair</span> <span class="kw">where</span></span>
-<span id="cb391-8"><a href="#cb391-8" aria-hidden="true" tabindex="-1"></a>  <span class="dt">IntPair</span> a1 a2 <span class="op">&lt;=</span> <span class="dt">IntPair</span> b1 b2</span>
-<span id="cb391-9"><a href="#cb391-9" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> a1<span class="op">&lt;</span>b1     <span class="ot">=</span> <span class="dt">True</span></span>
-<span id="cb391-10"><a href="#cb391-10" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> a1<span class="op">&gt;</span>b1     <span class="ot">=</span> <span class="dt">False</span></span>
-<span id="cb391-11"><a href="#cb391-11" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span> a2<span class="op">&lt;=</span>b2</span></code></pre></div>
-<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb392-1"><a href="#cb392-1" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="op">&lt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</span>
-<span id="cb392-2"><a href="#cb392-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
-<span id="cb392-3"><a href="#cb392-3" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</span>
-<span id="cb392-4"><a href="#cb392-4" aria-hidden="true" tabindex="-1"></a><span class="dt">False</span></span>
-<span id="cb392-5"><a href="#cb392-5" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&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>)</span>
-<span id="cb392-6"><a href="#cb392-6" aria-hidden="true" tabindex="-1"></a><span class="dt">LT</span></span>
-<span id="cb392-7"><a href="#cb392-7" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span> <span class="dt">Data.List</span><span class="op">&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>]</span>
-<span id="cb392-8"><a href="#cb392-8" aria-hidden="true" tabindex="-1"></a>[<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>]</span></code></pre></div>
-<h2 data-number="6.4" id="useful-stuff"><span class="header-section-number">6.4</span> Useful Stuff</h2>
-<h3 data-number="6.4.1" id="deriving"><span class="header-section-number">6.4.1</span> Deriving</h3>
+<div class="sourceCode" id="cb388"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb388-1"><a href="#cb388-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">IntPair</span> <span class="ot">=</span> <span class="dt">IntPair</span> <span class="dt">Int</span> <span class="dt">Int</span></span>
+<span id="cb388-2"><a href="#cb388-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
+<span id="cb388-3"><a href="#cb388-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb388-4"><a href="#cb388-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Eq</span> <span class="dt">IntPair</span> <span class="kw">where</span></span>
+<span id="cb388-5"><a href="#cb388-5" aria-hidden="true" tabindex="-1"></a>  <span class="dt">IntPair</span> a1 a2 <span class="op">==</span> <span class="dt">IntPair</span> b1 b2  <span class="ot">=</span>  a1<span class="op">==</span>b1 <span class="op">&amp;&amp;</span> a2<span class="op">==</span>b2</span>
+<span id="cb388-6"><a href="#cb388-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb388-7"><a href="#cb388-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Ord</span> <span class="dt">IntPair</span> <span class="kw">where</span></span>
+<span id="cb388-8"><a href="#cb388-8" aria-hidden="true" tabindex="-1"></a>  <span class="dt">IntPair</span> a1 a2 <span class="op">&lt;=</span> <span class="dt">IntPair</span> b1 b2</span>
+<span id="cb388-9"><a href="#cb388-9" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> a1<span class="op">&lt;</span>b1     <span class="ot">=</span> <span class="dt">True</span></span>
+<span id="cb388-10"><a href="#cb388-10" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> a1<span class="op">&gt;</span>b1     <span class="ot">=</span> <span class="dt">False</span></span>
+<span id="cb388-11"><a href="#cb388-11" aria-hidden="true" tabindex="-1"></a>     <span class="op">|</span> <span class="fu">otherwise</span> <span class="ot">=</span> a2<span class="op">&lt;=</span>b2</span></code></pre></div>
+<div class="sourceCode" id="cb389"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb389-1"><a href="#cb389-1" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="op">&lt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</span>
+<span id="cb389-2"><a href="#cb389-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb389-3"><a href="#cb389-3" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">1</span> <span class="dv">2</span>) <span class="op">&gt;</span> (<span class="dt">IntPair</span> <span class="dv">2</span> <span class="dv">3</span>)</span>
+<span id="cb389-4"><a href="#cb389-4" aria-hidden="true" tabindex="-1"></a><span class="dt">False</span></span>
+<span id="cb389-5"><a href="#cb389-5" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span><span class="op">&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>)</span>
+<span id="cb389-6"><a href="#cb389-6" aria-hidden="true" tabindex="-1"></a><span class="dt">LT</span></span>
+<span id="cb389-7"><a href="#cb389-7" aria-hidden="true" tabindex="-1"></a><span class="op">*</span><span class="dt">Main</span> <span class="dt">Data.List</span><span class="op">&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>]</span>
+<span id="cb389-8"><a href="#cb389-8" aria-hidden="true" tabindex="-1"></a>[<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>]</span></code></pre></div>
+<h2 data-number="6.3" id="useful-stuff"><span class="header-section-number">6.3</span> Useful Stuff</h2>
+<h3 data-number="6.3.1" id="deriving"><span class="header-section-number">6.3.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="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb393-1"><a href="#cb393-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Person</span> <span class="ot">=</span> <span class="dt">Dead</span> <span class="op">|</span> <span class="dt">Alive</span> <span class="dt">String</span> <span class="dt">Int</span></span>
-<span id="cb393-2"><a href="#cb393-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</span></code></pre></div>
-<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb394-1"><a href="#cb394-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Dead</span> <span class="op">&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></span>
-<span id="cb394-2"><a href="#cb394-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
-<span id="cb394-3"><a href="#cb394-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Barbara&quot;</span> <span class="dv">35</span> <span class="op">&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></span>
-<span id="cb394-4"><a href="#cb394-4" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
-<span id="cb394-5"><a href="#cb394-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span> <span class="op">&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></span>
-<span id="cb394-6"><a href="#cb394-6" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span></code></pre></div>
-<h3 data-number="6.4.2" id="asking-ghci-about-classes"><span class="header-section-number">6.4.2</span> Asking GHCi About Classes</h3>
+<div class="sourceCode" id="cb390"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb390-1"><a href="#cb390-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Person</span> <span class="ot">=</span> <span class="dt">Dead</span> <span class="op">|</span> <span class="dt">Alive</span> <span class="dt">String</span> <span class="dt">Int</span></span>
+<span id="cb390-2"><a href="#cb390-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>, <span class="dt">Ord</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb391"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb391-1"><a href="#cb391-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Dead</span> <span class="op">&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></span>
+<span id="cb391-2"><a href="#cb391-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb391-3"><a href="#cb391-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Barbara&quot;</span> <span class="dv">35</span> <span class="op">&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></span>
+<span id="cb391-4"><a href="#cb391-4" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb391-5"><a href="#cb391-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">Alive</span> <span class="st">&quot;Clive&quot;</span> <span class="dv">17</span> <span class="op">&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></span>
+<span id="cb391-6"><a href="#cb391-6" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span></code></pre></div>
+<h3 data-number="6.3.2" id="asking-ghci-about-classes"><span class="header-section-number">6.3.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="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb395-1"><a href="#cb395-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>info <span class="dt">Num</span></span>
-<span id="cb395-2"><a href="#cb395-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Num</span> a <span class="kw">where</span></span>
-<span id="cb395-3"><a href="#cb395-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (+) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-4"><a href="#cb395-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  (-) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-5"><a href="#cb395-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  (*) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-6"><a href="#cb395-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  negate ::</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-7"><a href="#cb395-7" aria-hidden="true" tabindex="-1"></a><span class="ot">  abs ::</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-8"><a href="#cb395-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  signum ::</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb395-9"><a href="#cb395-9" aria-hidden="true" tabindex="-1"></a><span class="ot">  fromInteger ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</span>
-<span id="cb395-10"><a href="#cb395-10" aria-hidden="true" tabindex="-1"></a>  <span class="ot">{-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}</span></span>
-<span id="cb395-11"><a href="#cb395-11" aria-hidden="true" tabindex="-1"></a>    <span class="co">-- Defined in ‘GHC.Num’</span></span>
-<span id="cb395-12"><a href="#cb395-12" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Word</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
-<span id="cb395-13"><a href="#cb395-13" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Integer</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
-<span id="cb395-14"><a href="#cb395-14" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Int</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
-<span id="cb395-15"><a href="#cb395-15" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Float</span> <span class="co">-- Defined in ‘GHC.Float’</span></span>
-<span id="cb395-16"><a href="#cb395-16" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Double</span> <span class="co">-- Defined in ‘GHC.Float’</span></span></code></pre></div>
-<h2 data-number="6.5" id="hierarchies"><span class="header-section-number">6.5</span> Hierarchies</h2>
+<div class="sourceCode" id="cb392"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb392-1"><a href="#cb392-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>info <span class="dt">Num</span></span>
+<span id="cb392-2"><a href="#cb392-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Num</span> a <span class="kw">where</span></span>
+<span id="cb392-3"><a href="#cb392-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (+) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-4"><a href="#cb392-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  (-) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-5"><a href="#cb392-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  (*) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-6"><a href="#cb392-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  negate ::</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-7"><a href="#cb392-7" aria-hidden="true" tabindex="-1"></a><span class="ot">  abs ::</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-8"><a href="#cb392-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  signum ::</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb392-9"><a href="#cb392-9" aria-hidden="true" tabindex="-1"></a><span class="ot">  fromInteger ::</span> <span class="dt">Integer</span> <span class="ot">-&gt;</span> a</span>
+<span id="cb392-10"><a href="#cb392-10" aria-hidden="true" tabindex="-1"></a>  <span class="ot">{-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}</span></span>
+<span id="cb392-11"><a href="#cb392-11" aria-hidden="true" tabindex="-1"></a>    <span class="co">-- Defined in ‘GHC.Num’</span></span>
+<span id="cb392-12"><a href="#cb392-12" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Word</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
+<span id="cb392-13"><a href="#cb392-13" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Integer</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
+<span id="cb392-14"><a href="#cb392-14" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Int</span> <span class="co">-- Defined in ‘GHC.Num’</span></span>
+<span id="cb392-15"><a href="#cb392-15" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Float</span> <span class="co">-- Defined in ‘GHC.Float’</span></span>
+<span id="cb392-16"><a href="#cb392-16" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> <span class="dt">Double</span> <span class="co">-- Defined in ‘GHC.Float’</span></span></code></pre></div>
+<h2 data-number="6.4" id="hierarchies"><span class="header-section-number">6.4</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 data-number="6.5.1" id="instance-hierarchies"><span class="header-section-number">6.5.1</span> Instance Hierarchies</h3>
+<h3 data-number="6.4.1" id="instance-hierarchies"><span class="header-section-number">6.4.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="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb396-1"><a href="#cb396-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Pair</span> a <span class="ot">=</span> <span class="dt">MakePair</span> a a</span>
-<span id="cb396-2"><a href="#cb396-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
-<span id="cb396-3"><a href="#cb396-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb396-4"><a href="#cb396-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></span>
-<span id="cb396-5"><a href="#cb396-5" aria-hidden="true" tabindex="-1"></a>  (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b)   <span class="ot">=</span>   x<span class="op">==</span>a <span class="op">&amp;&amp;</span> y<span class="op">==</span>b</span></code></pre></div>
-<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb397-1"><a href="#cb397-1" aria-hidden="true" tabindex="-1"></a><span class="fu">error</span><span class="op">:</span></span>
-<span id="cb397-2"><a href="#cb397-2" aria-hidden="true" tabindex="-1"></a>    • <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="op">==</span>’</span>
-<span id="cb397-3"><a href="#cb397-3" aria-hidden="true" tabindex="-1"></a>      <span class="dt">Possible</span> fix<span class="op">:</span> add (<span class="dt">Eq</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</span>
-<span id="cb397-4"><a href="#cb397-4" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘(<span class="op">&amp;&amp;</span>)’, namely ‘x <span class="op">==</span> a’</span>
-<span id="cb397-5"><a href="#cb397-5" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> the expression<span class="op">:</span> x <span class="op">==</span> a <span class="op">&amp;&amp;</span> y <span class="op">==</span> b</span>
-<span id="cb397-6"><a href="#cb397-6" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘<span class="op">==</span>’<span class="op">:</span></span>
-<span id="cb397-7"><a href="#cb397-7" aria-hidden="true" tabindex="-1"></a>          (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b) <span class="ot">=</span> x <span class="op">==</span> a <span class="op">&amp;&amp;</span> y <span class="op">==</span> b</span></code></pre></div>
+<div class="sourceCode" id="cb393"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb393-1"><a href="#cb393-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Pair</span> a <span class="ot">=</span> <span class="dt">MakePair</span> a a</span>
+<span id="cb393-2"><a href="#cb393-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
+<span id="cb393-3"><a href="#cb393-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb393-4"><a href="#cb393-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Eq</span> (<span class="dt">Pair</span> a) <span class="kw">where</span></span>
+<span id="cb393-5"><a href="#cb393-5" aria-hidden="true" tabindex="-1"></a>  (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b)   <span class="ot">=</span>   x<span class="op">==</span>a <span class="op">&amp;&amp;</span> y<span class="op">==</span>b</span></code></pre></div>
+<div class="sourceCode" id="cb394"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb394-1"><a href="#cb394-1" aria-hidden="true" tabindex="-1"></a><span class="fu">error</span><span class="op">:</span></span>
+<span id="cb394-2"><a href="#cb394-2" aria-hidden="true" tabindex="-1"></a>    • <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="op">==</span>’</span>
+<span id="cb394-3"><a href="#cb394-3" aria-hidden="true" tabindex="-1"></a>      <span class="dt">Possible</span> fix<span class="op">:</span> add (<span class="dt">Eq</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</span>
+<span id="cb394-4"><a href="#cb394-4" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the first argument <span class="kw">of</span> ‘(<span class="op">&amp;&amp;</span>)’, namely ‘x <span class="op">==</span> a’</span>
+<span id="cb394-5"><a href="#cb394-5" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> the expression<span class="op">:</span> x <span class="op">==</span> a <span class="op">&amp;&amp;</span> y <span class="op">==</span> b</span>
+<span id="cb394-6"><a href="#cb394-6" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘<span class="op">==</span>’<span class="op">:</span></span>
+<span id="cb394-7"><a href="#cb394-7" aria-hidden="true" tabindex="-1"></a>          (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b) <span class="ot">=</span> x <span class="op">==</span> a <span class="op">&amp;&amp;</span> y <span class="op">==</span> b</span></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="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb398-1"><a href="#cb398-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb398-2"><a href="#cb398-2" aria-hidden="true" tabindex="-1"></a>  (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b)   <span class="ot">=</span>   x<span class="op">==</span>a <span class="op">&amp;&amp;</span> y<span class="op">==</span>b</span></code></pre></div>
+<div class="sourceCode" id="cb395"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb395-1"><a href="#cb395-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb395-2"><a href="#cb395-2" aria-hidden="true" tabindex="-1"></a>  (<span class="dt">MakePair</span> x y) <span class="op">==</span> (<span class="dt">MakePair</span> a b)   <span class="ot">=</span>   x<span class="op">==</span>a <span class="op">&amp;&amp;</span> y<span class="op">==</span>b</span></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="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb399-1"><a href="#cb399-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span></span>
-<span id="cb399-2"><a href="#cb399-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
-<span id="cb399-3"><a href="#cb399-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span>
-<span id="cb399-4"><a href="#cb399-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb399-5"><a href="#cb399-5" aria-hidden="true" tabindex="-1"></a><span class="op">&lt;</span>interactive<span class="op">&gt;:</span><span class="dv">15</span><span class="op">:</span><span class="dv">1</span><span class="op">:</span> <span class="fu">error</span><span class="op">:</span></span>
-<span id="cb399-6"><a href="#cb399-6" aria-hidden="true" tabindex="-1"></a>    • <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="op">==</span>’</span>
-<span id="cb399-7"><a href="#cb399-7" aria-hidden="true" tabindex="-1"></a>        (<span class="fu">maybe</span> you haven&#39;t applied a function to enough arguments<span class="op">?</span>)</span>
-<span id="cb399-8"><a href="#cb399-8" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the expression<span class="op">:</span></span>
-<span id="cb399-9"><a href="#cb399-9" aria-hidden="true" tabindex="-1"></a>        <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span>
-<span id="cb399-10"><a href="#cb399-10" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘it’<span class="op">:</span></span>
-<span id="cb399-11"><a href="#cb399-11" aria-hidden="true" tabindex="-1"></a>          it <span class="ot">=</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span></code></pre></div>
+<div class="sourceCode" id="cb396"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb396-1"><a href="#cb396-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="dv">1</span> <span class="dv">1</span></span>
+<span id="cb396-2"><a href="#cb396-2" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb396-3"><a href="#cb396-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span>
+<span id="cb396-4"><a href="#cb396-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb396-5"><a href="#cb396-5" aria-hidden="true" tabindex="-1"></a><span class="op">&lt;</span>interactive<span class="op">&gt;:</span><span class="dv">15</span><span class="op">:</span><span class="dv">1</span><span class="op">:</span> <span class="fu">error</span><span class="op">:</span></span>
+<span id="cb396-6"><a href="#cb396-6" aria-hidden="true" tabindex="-1"></a>    • <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="op">==</span>’</span>
+<span id="cb396-7"><a href="#cb396-7" aria-hidden="true" tabindex="-1"></a>        (<span class="fu">maybe</span> you haven&#39;t applied a function to enough arguments<span class="op">?</span>)</span>
+<span id="cb396-8"><a href="#cb396-8" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the expression<span class="op">:</span></span>
+<span id="cb396-9"><a href="#cb396-9" aria-hidden="true" tabindex="-1"></a>        <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span>
+<span id="cb396-10"><a href="#cb396-10" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘it’<span class="op">:</span></span>
+<span id="cb396-11"><a href="#cb396-11" aria-hidden="true" tabindex="-1"></a>          it <span class="ot">=</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span> <span class="op">==</span> <span class="dt">MakePair</span> <span class="fu">reverse</span> <span class="fu">reverse</span></span></code></pre></div>
 <p>Let’s continue with another example. Here’s a simple type class and an instance</p>
-<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb400-1"><a href="#cb400-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Check</span> a <span class="kw">where</span></span>
-<span id="cb400-2"><a href="#cb400-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  check ::</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
-<span id="cb400-3"><a href="#cb400-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb400-4"><a href="#cb400-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Check</span> <span class="dt">Int</span> <span class="kw">where</span></span>
-<span id="cb400-5"><a href="#cb400-5" aria-hidden="true" tabindex="-1"></a>  check x <span class="ot">=</span> x <span class="op">&gt;</span> <span class="dv">0</span></span></code></pre></div>
+<div class="sourceCode" id="cb397"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb397-1"><a href="#cb397-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Check</span> a <span class="kw">where</span></span>
+<span id="cb397-2"><a href="#cb397-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  check ::</span> a <span class="ot">-&gt;</span> <span class="dt">Bool</span></span>
+<span id="cb397-3"><a href="#cb397-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb397-4"><a href="#cb397-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Check</span> <span class="dt">Int</span> <span class="kw">where</span></span>
+<span id="cb397-5"><a href="#cb397-5" aria-hidden="true" tabindex="-1"></a>  check x <span class="ot">=</span> x <span class="op">&gt;</span> <span class="dv">0</span></span></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="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb401-1"><a href="#cb401-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb401-2"><a href="#cb401-2" aria-hidden="true" tabindex="-1"></a>checkAll xs <span class="ot">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</span></code></pre></div>
+<div class="sourceCode" id="cb398"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb398-1"><a href="#cb398-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb398-2"><a href="#cb398-2" aria-hidden="true" tabindex="-1"></a>checkAll xs <span class="ot">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</span></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="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb402-1"><a href="#cb402-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb402-2"><a href="#cb402-2" aria-hidden="true" tabindex="-1"></a>  check xs <span class="ot">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</span></code></pre></div>
+<div class="sourceCode" id="cb399"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb399-1"><a href="#cb399-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb399-2"><a href="#cb399-2" aria-hidden="true" tabindex="-1"></a>  check xs <span class="ot">=</span> <span class="fu">and</span> (<span class="fu">map</span> check xs)</span></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="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb403-1"><a href="#cb403-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> check [<span class="dt">True</span>,<span class="dt">False</span>]</span>
-<span id="cb403-2"><a href="#cb403-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb403-3"><a href="#cb403-3" aria-hidden="true" tabindex="-1"></a><span class="op">&lt;</span>interactive<span class="op">&gt;:</span><span class="dv">1</span><span class="op">:</span><span class="dv">1</span><span class="op">:</span> <span class="fu">error</span><span class="op">:</span></span>
-<span id="cb403-4"><a href="#cb403-4" aria-hidden="true" tabindex="-1"></a>    • <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’</span>
-<span id="cb403-5"><a href="#cb403-5" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the expression<span class="op">:</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</span>
-<span id="cb403-6"><a href="#cb403-6" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘it’<span class="op">:</span> it <span class="ot">=</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb400"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb400-1"><a href="#cb400-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> check [<span class="dt">True</span>,<span class="dt">False</span>]</span>
+<span id="cb400-2"><a href="#cb400-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb400-3"><a href="#cb400-3" aria-hidden="true" tabindex="-1"></a><span class="op">&lt;</span>interactive<span class="op">&gt;:</span><span class="dv">1</span><span class="op">:</span><span class="dv">1</span><span class="op">:</span> <span class="fu">error</span><span class="op">:</span></span>
+<span id="cb400-4"><a href="#cb400-4" aria-hidden="true" tabindex="-1"></a>    • <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’</span>
+<span id="cb400-5"><a href="#cb400-5" aria-hidden="true" tabindex="-1"></a>    • <span class="dt">In</span> the expression<span class="op">:</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</span>
+<span id="cb400-6"><a href="#cb400-6" aria-hidden="true" tabindex="-1"></a>      <span class="dt">In</span> an equation for ‘it’<span class="op">:</span> it <span class="ot">=</span> check [<span class="dt">True</span>, <span class="dt">False</span>]</span></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="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb404-1"><a href="#cb404-1" aria-hidden="true" tabindex="-1"></a>    • <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’</span>
-<span id="cb404-2"><a href="#cb404-2" aria-hidden="true" tabindex="-1"></a>      <span class="dt">Possible</span> fix<span class="op">:</span></span>
-<span id="cb404-3"><a href="#cb404-3" aria-hidden="true" tabindex="-1"></a>        add (<span class="dt">Check</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</span></code></pre></div>
+<div class="sourceCode" id="cb401"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb401-1"><a href="#cb401-1" aria-hidden="true" tabindex="-1"></a>    • <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’</span>
+<span id="cb401-2"><a href="#cb401-2" aria-hidden="true" tabindex="-1"></a>      <span class="dt">Possible</span> fix<span class="op">:</span></span>
+<span id="cb401-3"><a href="#cb401-3" aria-hidden="true" tabindex="-1"></a>        add (<span class="dt">Check</span> a) to the context <span class="kw">of</span> the <span class="kw">instance</span> declaration</span></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="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb405-1"><a href="#cb405-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb405-2"><a href="#cb405-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Left</span> x  <span class="op">==</span> <span class="dt">Left</span> y   <span class="ot">=</span>  x<span class="op">==</span>y</span>
-<span id="cb405-3"><a href="#cb405-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Right</span> x <span class="op">==</span> <span class="dt">Right</span> y  <span class="ot">=</span>  x<span class="op">==</span>y</span>
-<span id="cb405-4"><a href="#cb405-4" aria-hidden="true" tabindex="-1"></a>  _       <span class="op">==</span> _        <span class="ot">=</span>  <span class="dt">False</span></span></code></pre></div>
-<h3 data-number="6.5.2" id="class-hierarchy"><span class="header-section-number">6.5.2</span> Class Hierarchy</h3>
+<div class="sourceCode" id="cb402"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb402-1"><a href="#cb402-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb402-2"><a href="#cb402-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Left</span> x  <span class="op">==</span> <span class="dt">Left</span> y   <span class="ot">=</span>  x<span class="op">==</span>y</span>
+<span id="cb402-3"><a href="#cb402-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Right</span> x <span class="op">==</span> <span class="dt">Right</span> y  <span class="ot">=</span>  x<span class="op">==</span>y</span>
+<span id="cb402-4"><a href="#cb402-4" aria-hidden="true" tabindex="-1"></a>  _       <span class="op">==</span> _        <span class="ot">=</span>  <span class="dt">False</span></span></code></pre></div>
+<h3 data-number="6.4.2" id="class-hierarchy"><span class="header-section-number">6.4.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="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb406-1"><a href="#cb406-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></span>
-<span id="cb406-2"><a href="#cb406-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
-<span id="cb406-3"><a href="#cb406-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb406-4"><a href="#cb406-4" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb406-5"><a href="#cb406-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  sizeBoth ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
-<span id="cb406-6"><a href="#cb406-6" aria-hidden="true" tabindex="-1"></a>  sizeBoth x y <span class="ot">=</span> size x <span class="op">+</span> size y</span></code></pre></div>
+<div class="sourceCode" id="cb403"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb403-1"><a href="#cb403-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Size</span> a <span class="kw">where</span></span>
+<span id="cb403-2"><a href="#cb403-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  size ::</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
+<span id="cb403-3"><a href="#cb403-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb403-4"><a href="#cb403-4" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb403-5"><a href="#cb403-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  sizeBoth ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
+<span id="cb403-6"><a href="#cb403-6" aria-hidden="true" tabindex="-1"></a>  sizeBoth x y <span class="ot">=</span> size x <span class="op">+</span> size y</span></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="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb407-1"><a href="#cb407-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb407-2"><a href="#cb407-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span>
-<span id="cb407-3"><a href="#cb407-3" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb407-4"><a href="#cb407-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span></code></pre></div>
+<div class="sourceCode" id="cb404"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb404-1"><a href="#cb404-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb404-2"><a href="#cb404-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span>
+<span id="cb404-3"><a href="#cb404-3" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb404-4"><a href="#cb404-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span></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 data-number="6.6" id="quiz-5"><span class="header-section-number">6.6</span> Quiz</h2>
+<h2 data-number="6.5" id="quiz-5"><span class="header-section-number">6.5</span> Quiz</h2>
 <p>What are the functions in the <code>Eq</code> class?</p>
 <ol class="quiz">
 <li class="correct">
@@ -3634,15 +3611,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="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb408-1"><a href="#cb408-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">BitOperations</span> a <span class="kw">where</span></span>
-<span id="cb408-2"><a href="#cb408-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitNot ::</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb408-3"><a href="#cb408-3" aria-hidden="true" tabindex="-1"></a>  bitNot x <span class="ot">=</span> bitNand x x</span>
-<span id="cb408-4"><a href="#cb408-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitAnd ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb408-5"><a href="#cb408-5" aria-hidden="true" tabindex="-1"></a>  bitAnd x y <span class="ot">=</span> bitNot (bitOr (bitNot x) (bitNot y))</span>
-<span id="cb408-6"><a href="#cb408-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitOr ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb408-7"><a href="#cb408-7" aria-hidden="true" tabindex="-1"></a>  bitOr x y <span class="ot">=</span> bitNot (bitAnd (bitNot x) (bitNot y))</span>
-<span id="cb408-8"><a href="#cb408-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitNand ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb408-9"><a href="#cb408-9" aria-hidden="true" tabindex="-1"></a>  bitNand x y <span class="ot">=</span> bitNot (bitAnd x y)</span></code></pre></div>
+<div class="sourceCode" id="cb405"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb405-1"><a href="#cb405-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">BitOperations</span> a <span class="kw">where</span></span>
+<span id="cb405-2"><a href="#cb405-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitNot ::</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb405-3"><a href="#cb405-3" aria-hidden="true" tabindex="-1"></a>  bitNot x <span class="ot">=</span> bitNand x x</span>
+<span id="cb405-4"><a href="#cb405-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitAnd ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb405-5"><a href="#cb405-5" aria-hidden="true" tabindex="-1"></a>  bitAnd x y <span class="ot">=</span> bitNot (bitOr (bitNot x) (bitNot y))</span>
+<span id="cb405-6"><a href="#cb405-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitOr ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb405-7"><a href="#cb405-7" aria-hidden="true" tabindex="-1"></a>  bitOr x y <span class="ot">=</span> bitNot (bitAnd (bitNot x) (bitNot y))</span>
+<span id="cb405-8"><a href="#cb405-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  bitNand ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb405-9"><a href="#cb405-9" aria-hidden="true" tabindex="-1"></a>  bitNand x y <span class="ot">=</span> bitNot (bitAnd x y)</span></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>
@@ -3685,7 +3662,7 @@ If I define an instance for <code>Fractional</code>, I also get an instance for
 If I define an instance for <code>Num</code>, I also get an instance for <code>Fractional</code>
 </li>
 </ol>
-<h2 data-number="6.7" id="exercises-5"><span class="header-section-number">6.7</span> Exercises</h2>
+<h2 data-number="6.6" id="exercises-5"><span class="header-section-number">6.6</span> Exercises</h2>
 <ul>
 <li><a href="https://github.com/moocfi/haskell-mooc/blob/master/exercises/Set6.hs">Set6</a>: defining classes and instances</li>
 </ul>
@@ -3694,84 +3671,84 @@ If I define an instance for <code>Num</code>, I also get an instance for <code>F
 <h2 data-number="7.1" 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="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb409-1"><a href="#cb409-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Plate</span> <span class="ot">=</span> <span class="dt">Plate</span> <span class="dt">String</span></span>
-<span id="cb409-2"><a href="#cb409-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb406"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb406-1"><a href="#cb406-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Plate</span> <span class="ot">=</span> <span class="dt">Plate</span> <span class="dt">String</span></span>
+<span id="cb406-2"><a href="#cb406-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> (<span class="dt">Show</span>, <span class="dt">Eq</span>)</span></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="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb410-1"><a href="#cb410-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb410-2"><a href="#cb410-2" aria-hidden="true" tabindex="-1"></a>parsePlate string</span>
-<span id="cb410-3"><a href="#cb410-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> correctPlateNumber string  <span class="ot">=</span>  <span class="dt">Just</span> (<span class="dt">Plate</span> string)</span>
-<span id="cb410-4"><a href="#cb410-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="fu">otherwise</span>                  <span class="ot">=</span>  <span class="dt">Nothing</span></span></code></pre></div>
+<div class="sourceCode" id="cb407"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb407-1"><a href="#cb407-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb407-2"><a href="#cb407-2" aria-hidden="true" tabindex="-1"></a>parsePlate string</span>
+<span id="cb407-3"><a href="#cb407-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> correctPlateNumber string  <span class="ot">=</span>  <span class="dt">Just</span> (<span class="dt">Plate</span> string)</span>
+<span id="cb407-4"><a href="#cb407-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="fu">otherwise</span>                  <span class="ot">=</span>  <span class="dt">Nothing</span></span></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="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb411-1"><a href="#cb411-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Money</span> <span class="ot">=</span> <span class="dt">Money</span> <span class="dt">Int</span></span>
-<span id="cb411-2"><a href="#cb411-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
-<span id="cb411-3"><a href="#cb411-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb411-4"><a href="#cb411-4" aria-hidden="true" tabindex="-1"></a><span class="ot">renderMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span>
-<span id="cb411-5"><a href="#cb411-5" aria-hidden="true" tabindex="-1"></a>renderMoney (<span class="dt">Money</span> cents) <span class="ot">=</span> <span class="fu">show</span> (<span class="fu">fromIntegral</span> cents <span class="op">/</span> <span class="dv">100</span>)</span>
-<span id="cb411-6"><a href="#cb411-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb411-7"><a href="#cb411-7" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb411-8"><a href="#cb411-8" aria-hidden="true" tabindex="-1"></a>(<span class="dt">Money</span> a) <span class="op">+!</span> (<span class="dt">Money</span> b) <span class="ot">=</span> <span class="dt">Money</span> (a<span class="op">+</span>b)</span>
-<span id="cb411-9"><a href="#cb411-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb411-10"><a href="#cb411-10" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb411-11"><a href="#cb411-11" aria-hidden="true" tabindex="-1"></a>scale (<span class="dt">Money</span> a) x <span class="ot">=</span> <span class="dt">Money</span> (<span class="fu">round</span> (<span class="fu">fromIntegral</span> a <span class="op">*</span> x))</span>
-<span id="cb411-12"><a href="#cb411-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb411-13"><a href="#cb411-13" aria-hidden="true" tabindex="-1"></a><span class="ot">addVat ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></span>
-<span id="cb411-14"><a href="#cb411-14" aria-hidden="true" tabindex="-1"></a>addVat m <span class="ot">=</span> m <span class="op">+!</span> scale m <span class="fl">0.24</span></span></code></pre></div>
-<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb412-1"><a href="#cb412-1" aria-hidden="true" tabindex="-1"></a>renderMoney (<span class="dt">Money</span> <span class="dv">100</span> <span class="op">+!</span> <span class="dt">Money</span> <span class="dv">150</span>)</span>
-<span id="cb412-2"><a href="#cb412-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="st">&quot;2.5&quot;</span></span>
-<span id="cb412-3"><a href="#cb412-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb412-4"><a href="#cb412-4" aria-hidden="true" tabindex="-1"></a>scale (<span class="dt">Money</span> <span class="dv">299</span>) <span class="fl">0.24</span></span>
-<span id="cb412-5"><a href="#cb412-5" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dt">Money</span> <span class="dv">72</span></span>
-<span id="cb412-6"><a href="#cb412-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb412-7"><a href="#cb412-7" aria-hidden="true" tabindex="-1"></a>addVat (<span class="dt">Money</span> <span class="dv">299</span>)</span>
-<span id="cb412-8"><a href="#cb412-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dt">Money</span> <span class="dv">371</span></span></code></pre></div>
+<div class="sourceCode" id="cb408"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb408-1"><a href="#cb408-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Money</span> <span class="ot">=</span> <span class="dt">Money</span> <span class="dt">Int</span></span>
+<span id="cb408-2"><a href="#cb408-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
+<span id="cb408-3"><a href="#cb408-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb408-4"><a href="#cb408-4" aria-hidden="true" tabindex="-1"></a><span class="ot">renderMoney ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span>
+<span id="cb408-5"><a href="#cb408-5" aria-hidden="true" tabindex="-1"></a>renderMoney (<span class="dt">Money</span> cents) <span class="ot">=</span> <span class="fu">show</span> (<span class="fu">fromIntegral</span> cents <span class="op">/</span> <span class="dv">100</span>)</span>
+<span id="cb408-6"><a href="#cb408-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb408-7"><a href="#cb408-7" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb408-8"><a href="#cb408-8" aria-hidden="true" tabindex="-1"></a>(<span class="dt">Money</span> a) <span class="op">+!</span> (<span class="dt">Money</span> b) <span class="ot">=</span> <span class="dt">Money</span> (a<span class="op">+</span>b)</span>
+<span id="cb408-9"><a href="#cb408-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb408-10"><a href="#cb408-10" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb408-11"><a href="#cb408-11" aria-hidden="true" tabindex="-1"></a>scale (<span class="dt">Money</span> a) x <span class="ot">=</span> <span class="dt">Money</span> (<span class="fu">round</span> (<span class="fu">fromIntegral</span> a <span class="op">*</span> x))</span>
+<span id="cb408-12"><a href="#cb408-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb408-13"><a href="#cb408-13" aria-hidden="true" tabindex="-1"></a><span class="ot">addVat ::</span> <span class="dt">Money</span> <span class="ot">-&gt;</span> <span class="dt">Money</span></span>
+<span id="cb408-14"><a href="#cb408-14" aria-hidden="true" tabindex="-1"></a>addVat m <span class="ot">=</span> m <span class="op">+!</span> scale m <span class="fl">0.24</span></span></code></pre></div>
+<div class="sourceCode" id="cb409"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb409-1"><a href="#cb409-1" aria-hidden="true" tabindex="-1"></a>renderMoney (<span class="dt">Money</span> <span class="dv">100</span> <span class="op">+!</span> <span class="dt">Money</span> <span class="dv">150</span>)</span>
+<span id="cb409-2"><a href="#cb409-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="st">&quot;2.5&quot;</span></span>
+<span id="cb409-3"><a href="#cb409-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb409-4"><a href="#cb409-4" aria-hidden="true" tabindex="-1"></a>scale (<span class="dt">Money</span> <span class="dv">299</span>) <span class="fl">0.24</span></span>
+<span id="cb409-5"><a href="#cb409-5" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dt">Money</span> <span class="dv">72</span></span>
+<span id="cb409-6"><a href="#cb409-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb409-7"><a href="#cb409-7" aria-hidden="true" tabindex="-1"></a>addVat (<span class="dt">Money</span> <span class="dv">299</span>)</span>
+<span id="cb409-8"><a href="#cb409-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dt">Money</span> <span class="dv">371</span></span></code></pre></div>
 <p><strong>Note!</strong> If you’re familiar with Object-Oriented Programming, this is a bit like encapsulation.</p>
 <h2 data-number="7.2" 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, "name", true)</code>. In Haskell you can do this instead:</p>
-<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb413-1"><a href="#cb413-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Person</span> <span class="ot">=</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>}</span>
-<span id="cb413-2"><a href="#cb413-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
-<span id="cb413-3"><a href="#cb413-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb413-4"><a href="#cb413-4" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">SortOrder</span> <span class="ot">=</span> <span class="dt">Ascending</span> <span class="op">|</span> <span class="dt">Descending</span></span>
-<span id="cb413-5"><a href="#cb413-5" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">SortField</span> <span class="ot">=</span> <span class="dt">Name</span> <span class="op">|</span> <span class="dt">Age</span></span>
-<span id="cb413-6"><a href="#cb413-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb413-7"><a href="#cb413-7" aria-hidden="true" tabindex="-1"></a><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>]</span>
-<span id="cb413-8"><a href="#cb413-8" aria-hidden="true" tabindex="-1"></a>sortByField <span class="dt">Name</span> ps <span class="ot">=</span> sortBy (comparing name) ps</span>
-<span id="cb413-9"><a href="#cb413-9" aria-hidden="true" tabindex="-1"></a>sortByField <span class="dt">Age</span> ps <span class="ot">=</span> sortBy (comparing age) ps</span>
-<span id="cb413-10"><a href="#cb413-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb413-11"><a href="#cb413-11" aria-hidden="true" tabindex="-1"></a><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>]</span>
-<span id="cb413-12"><a href="#cb413-12" aria-hidden="true" tabindex="-1"></a>sortPersons field <span class="dt">Ascending</span> ps <span class="ot">=</span> sortByField field ps</span>
-<span id="cb413-13"><a href="#cb413-13" aria-hidden="true" tabindex="-1"></a>sortPersons field <span class="dt">Descending</span> ps <span class="ot">=</span> <span class="fu">reverse</span> (sortByField field ps)</span>
-<span id="cb413-14"><a href="#cb413-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb413-15"><a href="#cb413-15" aria-hidden="true" tabindex="-1"></a>persons <span class="ot">=</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>]</span></code></pre></div>
-<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb414-1"><a href="#cb414-1" aria-hidden="true" tabindex="-1"></a>sortPersons <span class="dt">Name</span> <span class="dt">Ascending</span> persons</span>
-<span id="cb414-2"><a href="#cb414-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> [<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="ot">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="ot">=</span> <span class="dv">60</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="ot">=</span> <span class="dv">65</span>}]</span>
-<span id="cb414-3"><a href="#cb414-3" aria-hidden="true" tabindex="-1"></a>sortPersons <span class="dt">Age</span> <span class="dt">Descending</span> persons</span>
-<span id="cb414-4"><a href="#cb414-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> [<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="ot">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="ot">=</span> <span class="dv">65</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="ot">=</span> <span class="dv">60</span>}]</span></code></pre></div>
+<div class="sourceCode" id="cb410"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb410-1"><a href="#cb410-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Person</span> <span class="ot">=</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>}</span>
+<span id="cb410-2"><a href="#cb410-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> <span class="dt">Show</span></span>
+<span id="cb410-3"><a href="#cb410-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb410-4"><a href="#cb410-4" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">SortOrder</span> <span class="ot">=</span> <span class="dt">Ascending</span> <span class="op">|</span> <span class="dt">Descending</span></span>
+<span id="cb410-5"><a href="#cb410-5" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">SortField</span> <span class="ot">=</span> <span class="dt">Name</span> <span class="op">|</span> <span class="dt">Age</span></span>
+<span id="cb410-6"><a href="#cb410-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb410-7"><a href="#cb410-7" aria-hidden="true" tabindex="-1"></a><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>]</span>
+<span id="cb410-8"><a href="#cb410-8" aria-hidden="true" tabindex="-1"></a>sortByField <span class="dt">Name</span> ps <span class="ot">=</span> sortBy (comparing name) ps</span>
+<span id="cb410-9"><a href="#cb410-9" aria-hidden="true" tabindex="-1"></a>sortByField <span class="dt">Age</span> ps <span class="ot">=</span> sortBy (comparing age) ps</span>
+<span id="cb410-10"><a href="#cb410-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb410-11"><a href="#cb410-11" aria-hidden="true" tabindex="-1"></a><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>]</span>
+<span id="cb410-12"><a href="#cb410-12" aria-hidden="true" tabindex="-1"></a>sortPersons field <span class="dt">Ascending</span> ps <span class="ot">=</span> sortByField field ps</span>
+<span id="cb410-13"><a href="#cb410-13" aria-hidden="true" tabindex="-1"></a>sortPersons field <span class="dt">Descending</span> ps <span class="ot">=</span> <span class="fu">reverse</span> (sortByField field ps)</span>
+<span id="cb410-14"><a href="#cb410-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb410-15"><a href="#cb410-15" aria-hidden="true" tabindex="-1"></a>persons <span class="ot">=</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>]</span></code></pre></div>
+<div class="sourceCode" id="cb411"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb411-1"><a href="#cb411-1" aria-hidden="true" tabindex="-1"></a>sortPersons <span class="dt">Name</span> <span class="dt">Ascending</span> persons</span>
+<span id="cb411-2"><a href="#cb411-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> [<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="ot">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="ot">=</span> <span class="dv">60</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="ot">=</span> <span class="dv">65</span>}]</span>
+<span id="cb411-3"><a href="#cb411-3" aria-hidden="true" tabindex="-1"></a>sortPersons <span class="dt">Age</span> <span class="dt">Descending</span> persons</span>
+<span id="cb411-4"><a href="#cb411-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> [<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Fridolf&quot;</span>, age <span class="ot">=</span> <span class="dv">73</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Hans&quot;</span>, age <span class="ot">=</span> <span class="dv">65</span>},<span class="dt">Person</span> {name <span class="ot">=</span> <span class="st">&quot;Greta&quot;</span>, age <span class="ot">=</span> <span class="dv">60</span>}]</span></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.16.4.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="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb415-1"><a href="#cb415-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">NonEmpty</span> a <span class="ot">=</span> a <span class="op">:|</span> [a]</span></code></pre></div>
+<div class="sourceCode" id="cb412"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb412-1"><a href="#cb412-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">NonEmpty</span> a <span class="ot">=</span> a <span class="op">:|</span> [a]</span></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="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb416-1"><a href="#cb416-1" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span>
-<span id="cb416-2"><a href="#cb416-2" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">:|</span> []</span></code></pre></div>
+<div class="sourceCode" id="cb413"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb413-1"><a href="#cb413-1" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span>
+<span id="cb413-2"><a href="#cb413-2" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">:|</span> []</span></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="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb417-1"><a href="#cb417-1" aria-hidden="true" tabindex="-1"></a><span class="ot">nonEmpty ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> (<span class="dt">NonEmpty</span> a)</span>
-<span id="cb417-2"><a href="#cb417-2" aria-hidden="true" tabindex="-1"></a>nonEmpty [] <span class="ot">=</span> <span class="dt">Nothing</span></span>
-<span id="cb417-3"><a href="#cb417-3" aria-hidden="true" tabindex="-1"></a>nonEmpty (x<span class="op">:</span>xs) <span class="ot">=</span> <span class="dt">Just</span> (x <span class="op">:|</span> xs)</span>
-<span id="cb417-4"><a href="#cb417-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb417-5"><a href="#cb417-5" aria-hidden="true" tabindex="-1"></a><span class="ot">toList ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> [a]</span>
-<span id="cb417-6"><a href="#cb417-6" aria-hidden="true" tabindex="-1"></a>toList (x <span class="op">:|</span> xs) <span class="ot">=</span> x <span class="op">:</span> xs</span></code></pre></div>
-<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb418-1"><a href="#cb418-1" aria-hidden="true" tabindex="-1"></a>nonEmpty [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]     <span class="op">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])</span>
-<span id="cb418-2"><a href="#cb418-2" aria-hidden="true" tabindex="-1"></a>nonEmpty [<span class="dv">1</span>]         <span class="op">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="op">:|</span> [])</span>
-<span id="cb418-3"><a href="#cb418-3" aria-hidden="true" tabindex="-1"></a>nonEmpty []          <span class="op">==&gt;</span>  <span class="dt">Nothing</span></span>
-<span id="cb418-4"><a href="#cb418-4" aria-hidden="true" tabindex="-1"></a>toList (<span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb414"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb414-1"><a href="#cb414-1" aria-hidden="true" tabindex="-1"></a><span class="ot">nonEmpty ::</span> [a] <span class="ot">-&gt;</span> <span class="dt">Maybe</span> (<span class="dt">NonEmpty</span> a)</span>
+<span id="cb414-2"><a href="#cb414-2" aria-hidden="true" tabindex="-1"></a>nonEmpty [] <span class="ot">=</span> <span class="dt">Nothing</span></span>
+<span id="cb414-3"><a href="#cb414-3" aria-hidden="true" tabindex="-1"></a>nonEmpty (x<span class="op">:</span>xs) <span class="ot">=</span> <span class="dt">Just</span> (x <span class="op">:|</span> xs)</span>
+<span id="cb414-4"><a href="#cb414-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb414-5"><a href="#cb414-5" aria-hidden="true" tabindex="-1"></a><span class="ot">toList ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> [a]</span>
+<span id="cb414-6"><a href="#cb414-6" aria-hidden="true" tabindex="-1"></a>toList (x <span class="op">:|</span> xs) <span class="ot">=</span> x <span class="op">:</span> xs</span></code></pre></div>
+<div class="sourceCode" id="cb415"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb415-1"><a href="#cb415-1" aria-hidden="true" tabindex="-1"></a>nonEmpty [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]     <span class="op">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])</span>
+<span id="cb415-2"><a href="#cb415-2" aria-hidden="true" tabindex="-1"></a>nonEmpty [<span class="dv">1</span>]         <span class="op">==&gt;</span>  <span class="dt">Just</span> (<span class="dv">1</span> <span class="op">:|</span> [])</span>
+<span id="cb415-3"><a href="#cb415-3" aria-hidden="true" tabindex="-1"></a>nonEmpty []          <span class="op">==&gt;</span>  <span class="dt">Nothing</span></span>
+<span id="cb415-4"><a href="#cb415-4" aria-hidden="true" tabindex="-1"></a>toList (<span class="dv">1</span> <span class="op">:|</span> [<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</span></code></pre></div>
 <p>Here are <code>head</code> and <code>last</code> implemented for <code>NonEmpty</code>:</p>
-<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb419-1"><a href="#cb419-1" aria-hidden="true" tabindex="-1"></a>neHead (x <span class="op">:|</span> _) <span class="ot">=</span> x</span>
-<span id="cb419-2"><a href="#cb419-2" aria-hidden="true" tabindex="-1"></a>neLast (x <span class="op">:|</span> []) <span class="ot">=</span> x</span>
-<span id="cb419-3"><a href="#cb419-3" aria-hidden="true" tabindex="-1"></a>neLast (_ <span class="op">:|</span> xs) <span class="ot">=</span> <span class="fu">last</span> xs</span></code></pre></div>
-<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb420-1"><a href="#cb420-1" aria-hidden="true" tabindex="-1"></a>neHead (<span class="dv">1</span><span class="op">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  <span class="dv">1</span></span>
-<span id="cb420-2"><a href="#cb420-2" aria-hidden="true" tabindex="-1"></a>neLast (<span class="dv">1</span><span class="op">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  <span class="dv">3</span></span></code></pre></div>
+<div class="sourceCode" id="cb416"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb416-1"><a href="#cb416-1" aria-hidden="true" tabindex="-1"></a>neHead (x <span class="op">:|</span> _) <span class="ot">=</span> x</span>
+<span id="cb416-2"><a href="#cb416-2" aria-hidden="true" tabindex="-1"></a>neLast (x <span class="op">:|</span> []) <span class="ot">=</span> x</span>
+<span id="cb416-3"><a href="#cb416-3" aria-hidden="true" tabindex="-1"></a>neLast (_ <span class="op">:|</span> xs) <span class="ot">=</span> <span class="fu">last</span> xs</span></code></pre></div>
+<div class="sourceCode" id="cb417"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb417-1"><a href="#cb417-1" aria-hidden="true" tabindex="-1"></a>neHead (<span class="dv">1</span><span class="op">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  <span class="dv">1</span></span>
+<span id="cb417-2"><a href="#cb417-2" aria-hidden="true" tabindex="-1"></a>neLast (<span class="dv">1</span><span class="op">:|</span>[<span class="dv">2</span>,<span class="dv">3</span>])  <span class="op">==&gt;</span>  <span class="dv">3</span></span></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 data-number="7.3" id="monoids"><span class="header-section-number">7.3</span> Monoids</h2>
@@ -3780,197 +3757,197 @@ 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 data-number="7.3.1" 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="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb421-1"><a href="#cb421-1" aria-hidden="true" tabindex="-1"></a>(<span class="dv">1</span> <span class="op">+</span>  <span class="dv">3</span>) <span class="op">+</span> (<span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span>)</span>
-<span id="cb421-2"><a href="#cb421-2" aria-hidden="true" tabindex="-1"></a> <span class="dv">1</span> <span class="op">+</span> (<span class="dv">3</span>  <span class="op">+</span> (<span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span>))</span>
-<span id="cb421-3"><a href="#cb421-3" aria-hidden="true" tabindex="-1"></a> <span class="dv">1</span>  <span class="op">+</span> <span class="dv">3</span>  <span class="op">+</span>  <span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span></span></code></pre></div>
+<div class="sourceCode" id="cb418"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb418-1"><a href="#cb418-1" aria-hidden="true" tabindex="-1"></a>(<span class="dv">1</span> <span class="op">+</span>  <span class="dv">3</span>) <span class="op">+</span> (<span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span>)</span>
+<span id="cb418-2"><a href="#cb418-2" aria-hidden="true" tabindex="-1"></a> <span class="dv">1</span> <span class="op">+</span> (<span class="dv">3</span>  <span class="op">+</span> (<span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span>))</span>
+<span id="cb418-3"><a href="#cb418-3" aria-hidden="true" tabindex="-1"></a> <span class="dv">1</span>  <span class="op">+</span> <span class="dv">3</span>  <span class="op">+</span>  <span class="dv">5</span> <span class="op">+</span> <span class="dv">7</span></span></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="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb422-1"><a href="#cb422-1" aria-hidden="true" tabindex="-1"></a>f x (f y z)</span>
-<span id="cb422-2"><a href="#cb422-2" aria-hidden="true" tabindex="-1"></a>f (f x y) z</span></code></pre></div>
+<div class="sourceCode" id="cb419"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb419-1"><a href="#cb419-1" aria-hidden="true" tabindex="-1"></a>f x (f y z)</span>
+<span id="cb419-2"><a href="#cb419-2" aria-hidden="true" tabindex="-1"></a>f (f x y) z</span></code></pre></div>
 <p>Two widely-used associative functions are the <code>min</code> and <code>max</code> functions:</p>
-<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb423-1"><a href="#cb423-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">1</span></span>
-<span id="cb423-2"><a href="#cb423-2" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">1</span></span>
-<span id="cb423-3"><a href="#cb423-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb423-4"><a href="#cb423-4" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">3</span></span>
-<span id="cb423-5"><a href="#cb423-5" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">3</span></span></code></pre></div>
+<div class="sourceCode" id="cb420"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb420-1"><a href="#cb420-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">1</span></span>
+<span id="cb420-2"><a href="#cb420-2" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">1</span></span>
+<span id="cb420-3"><a href="#cb420-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb420-4"><a href="#cb420-4" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">3</span></span>
+<span id="cb420-5"><a href="#cb420-5" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span> <span class="dv">3</span></span></code></pre></div>
 <h3 data-number="7.3.2" 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="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb424-1"><a href="#cb424-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
-<span id="cb424-2"><a href="#cb424-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- An associative operation.</span></span>
-<span id="cb424-3"><a href="#cb424-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span></code></pre></div>
+<div class="sourceCode" id="cb421"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb421-1"><a href="#cb421-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
+<span id="cb421-2"><a href="#cb421-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- An associative operation.</span></span>
+<span id="cb421-3"><a href="#cb421-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span></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="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb425-1"><a href="#cb425-1" aria-hidden="true" tabindex="-1"></a>[<span class="dv">1</span>] <span class="op">&lt;&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="op">&lt;&gt;</span> [<span class="dv">4</span>]  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb422"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb422-1"><a href="#cb422-1" aria-hidden="true" tabindex="-1"></a>[<span class="dv">1</span>] <span class="op">&lt;&gt;</span> [<span class="dv">2</span>,<span class="dv">3</span>] <span class="op">&lt;&gt;</span> [<span class="dv">4</span>]  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span></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="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb426-1"><a href="#cb426-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Sum</span> a <span class="ot">=</span> <span class="dt">Sum</span> a</span>
-<span id="cb426-2"><a href="#cb426-2" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb426-3"><a href="#cb426-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Sum</span> a <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> b  <span class="ot">=</span>  <span class="dt">Sum</span> (a<span class="op">+</span>b)</span>
-<span id="cb426-4"><a href="#cb426-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb426-5"><a href="#cb426-5" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Product</span> a <span class="ot">=</span> <span class="dt">Product</span> a</span>
-<span id="cb426-6"><a href="#cb426-6" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb426-7"><a href="#cb426-7" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Product</span> a <span class="op">&lt;&gt;</span> <span class="dt">Product</span> b   <span class="ot">=</span>  <span class="dt">Product</span> (a<span class="op">*</span>b)</span></code></pre></div>
+<div class="sourceCode" id="cb423"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb423-1"><a href="#cb423-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Sum</span> a <span class="ot">=</span> <span class="dt">Sum</span> a</span>
+<span id="cb423-2"><a href="#cb423-2" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb423-3"><a href="#cb423-3" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Sum</span> a <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> b  <span class="ot">=</span>  <span class="dt">Sum</span> (a<span class="op">+</span>b)</span>
+<span id="cb423-4"><a href="#cb423-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb423-5"><a href="#cb423-5" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Product</span> a <span class="ot">=</span> <span class="dt">Product</span> a</span>
+<span id="cb423-6"><a href="#cb423-6" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb423-7"><a href="#cb423-7" aria-hidden="true" tabindex="-1"></a>  <span class="dt">Product</span> a <span class="op">&lt;&gt;</span> <span class="dt">Product</span> b   <span class="ot">=</span>  <span class="dt">Product</span> (a<span class="op">*</span>b)</span></code></pre></div>
 <p>By the way, this is another benefit of boxing things: being able to declare different type class instances!</p>
 <p>Note how the <code>Num a</code> constraint lets us use <code>Num</code> operations like <code>+</code> and <code>*</code> on the contained type <code>a</code>. We can have values like <code>Sum "abc" :: Sum String</code>, but they won’t have a <code>Semigroup</code> instance!</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="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb427-1"><a href="#cb427-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Semigroup</span></span>
-<span id="cb427-2"><a href="#cb427-2" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Product</span> (<span class="dv">2</span><span class="ot">::</span><span class="dt">Int</span>) <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></span>
-<span id="cb427-3"><a href="#cb427-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Product</span> {getProduct <span class="ot">=</span> <span class="dv">6</span>}</span>
-<span id="cb427-4"><a href="#cb427-4" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Sum</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">5</span> <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">7</span></span>
-<span id="cb427-5"><a href="#cb427-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Sum</span> {getSum <span class="ot">=</span> <span class="dv">15</span>}</span>
-<span id="cb427-6"><a href="#cb427-6" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Product</span> <span class="dv">2</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></span>
-<span id="cb427-7"><a href="#cb427-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Product</span> {getProduct <span class="ot">=</span> <span class="dv">6</span>}</span>
-<span id="cb427-8"><a href="#cb427-8" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Min</span> <span class="dv">4</span> <span class="op">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">5</span></span>
-<span id="cb427-9"><a href="#cb427-9" aria-hidden="true" tabindex="-1"></a><span class="dt">Min</span> {getMin <span class="ot">=</span> <span class="dv">3</span>}</span>
-<span id="cb427-10"><a href="#cb427-10" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Max</span> <span class="dv">4</span> <span class="op">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">5</span></span>
-<span id="cb427-11"><a href="#cb427-11" aria-hidden="true" tabindex="-1"></a><span class="dt">Max</span> {getMax <span class="ot">=</span> <span class="dv">5</span>}</span></code></pre></div>
+<div class="sourceCode" id="cb424"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb424-1"><a href="#cb424-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="kw">import</span> <span class="dt">Data.Semigroup</span></span>
+<span id="cb424-2"><a href="#cb424-2" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Product</span> (<span class="dv">2</span><span class="ot">::</span><span class="dt">Int</span>) <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></span>
+<span id="cb424-3"><a href="#cb424-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Product</span> {getProduct <span class="ot">=</span> <span class="dv">6</span>}</span>
+<span id="cb424-4"><a href="#cb424-4" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Sum</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">5</span> <span class="op">&lt;&gt;</span> <span class="dt">Sum</span> <span class="dv">7</span></span>
+<span id="cb424-5"><a href="#cb424-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Sum</span> {getSum <span class="ot">=</span> <span class="dv">15</span>}</span>
+<span id="cb424-6"><a href="#cb424-6" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Product</span> <span class="dv">2</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Product</span> <span class="dv">1</span></span>
+<span id="cb424-7"><a href="#cb424-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Product</span> {getProduct <span class="ot">=</span> <span class="dv">6</span>}</span>
+<span id="cb424-8"><a href="#cb424-8" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Min</span> <span class="dv">4</span> <span class="op">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Min</span> <span class="dv">5</span></span>
+<span id="cb424-9"><a href="#cb424-9" aria-hidden="true" tabindex="-1"></a><span class="dt">Min</span> {getMin <span class="ot">=</span> <span class="dv">3</span>}</span>
+<span id="cb424-10"><a href="#cb424-10" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span> <span class="dt">Data.Semigroup</span><span class="op">&gt;</span> <span class="dt">Max</span> <span class="dv">4</span> <span class="op">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">3</span> <span class="op">&lt;&gt;</span> <span class="dt">Max</span> <span class="dv">5</span></span>
+<span id="cb424-11"><a href="#cb424-11" aria-hidden="true" tabindex="-1"></a><span class="dt">Max</span> {getMax <span class="ot">=</span> <span class="dv">5</span>}</span></code></pre></div>
 <h3 data-number="7.3.3" 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="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb428-1"><a href="#cb428-1" aria-hidden="true" tabindex="-1"></a><span class="co">-- 0 is the neutral element of (+)</span></span>
-<span id="cb428-2"><a href="#cb428-2" aria-hidden="true" tabindex="-1"></a><span class="dv">3</span> <span class="op">+</span> <span class="dv">0</span>        <span class="op">==&gt;</span>  <span class="dv">3</span></span>
-<span id="cb428-3"><a href="#cb428-3" aria-hidden="true" tabindex="-1"></a><span class="dv">0</span> <span class="op">+</span> <span class="dv">3</span>        <span class="op">==&gt;</span>  <span class="dv">3</span></span>
-<span id="cb428-4"><a href="#cb428-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb428-5"><a href="#cb428-5" aria-hidden="true" tabindex="-1"></a><span class="co">-- 1 is the neutral element of (*)</span></span>
-<span id="cb428-6"><a href="#cb428-6" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">*</span> <span class="dv">5</span>        <span class="op">==&gt;</span>  <span class="dv">5</span></span>
-<span id="cb428-7"><a href="#cb428-7" aria-hidden="true" tabindex="-1"></a><span class="dv">5</span> <span class="op">*</span> <span class="dv">1</span>        <span class="op">==&gt;</span>  <span class="dv">5</span></span>
-<span id="cb428-8"><a href="#cb428-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb428-9"><a href="#cb428-9" aria-hidden="true" tabindex="-1"></a><span class="co">-- [] is the neutral element of (++)</span></span>
-<span id="cb428-10"><a href="#cb428-10" aria-hidden="true" tabindex="-1"></a>[] <span class="op">++</span> [<span class="dv">1</span>,<span class="dv">2</span>]  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</span>
-<span id="cb428-11"><a href="#cb428-11" aria-hidden="true" tabindex="-1"></a>[<span class="dv">1</span>,<span class="dv">2</span>] <span class="op">++</span> []  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb425"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb425-1"><a href="#cb425-1" aria-hidden="true" tabindex="-1"></a><span class="co">-- 0 is the neutral element of (+)</span></span>
+<span id="cb425-2"><a href="#cb425-2" aria-hidden="true" tabindex="-1"></a><span class="dv">3</span> <span class="op">+</span> <span class="dv">0</span>        <span class="op">==&gt;</span>  <span class="dv">3</span></span>
+<span id="cb425-3"><a href="#cb425-3" aria-hidden="true" tabindex="-1"></a><span class="dv">0</span> <span class="op">+</span> <span class="dv">3</span>        <span class="op">==&gt;</span>  <span class="dv">3</span></span>
+<span id="cb425-4"><a href="#cb425-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb425-5"><a href="#cb425-5" aria-hidden="true" tabindex="-1"></a><span class="co">-- 1 is the neutral element of (*)</span></span>
+<span id="cb425-6"><a href="#cb425-6" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="op">*</span> <span class="dv">5</span>        <span class="op">==&gt;</span>  <span class="dv">5</span></span>
+<span id="cb425-7"><a href="#cb425-7" aria-hidden="true" tabindex="-1"></a><span class="dv">5</span> <span class="op">*</span> <span class="dv">1</span>        <span class="op">==&gt;</span>  <span class="dv">5</span></span>
+<span id="cb425-8"><a href="#cb425-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb425-9"><a href="#cb425-9" aria-hidden="true" tabindex="-1"></a><span class="co">-- [] is the neutral element of (++)</span></span>
+<span id="cb425-10"><a href="#cb425-10" aria-hidden="true" tabindex="-1"></a>[] <span class="op">++</span> [<span class="dv">1</span>,<span class="dv">2</span>]  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</span>
+<span id="cb425-11"><a href="#cb425-11" aria-hidden="true" tabindex="-1"></a>[<span class="dv">1</span>,<span class="dv">2</span>] <span class="op">++</span> []  <span class="op">==&gt;</span>  [<span class="dv">1</span>,<span class="dv">2</span>]</span></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="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb429-1"><a href="#cb429-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb429-2"><a href="#cb429-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- The neutral element</span></span>
-<span id="cb429-3"><a href="#cb429-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty ::</span> a</span></code></pre></div>
+<div class="sourceCode" id="cb426"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb426-1"><a href="#cb426-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb426-2"><a href="#cb426-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- The neutral element</span></span>
+<span id="cb426-3"><a href="#cb426-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty ::</span> a</span></code></pre></div>
 <p>Here are the <code>Monoid</code> instances corresponding to our three examples of neutral elements:</p>
-<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb430-1"><a href="#cb430-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></span>
-<span id="cb430-2"><a href="#cb430-2" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="dt">Sum</span> <span class="dv">0</span></span>
-<span id="cb430-3"><a href="#cb430-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb430-4"><a href="#cb430-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> (<span class="dt">Product</span> a) <span class="kw">where</span></span>
-<span id="cb430-5"><a href="#cb430-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="dt">Product</span> <span class="dv">1</span></span>
-<span id="cb430-6"><a href="#cb430-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb430-7"><a href="#cb430-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Monoid</span> [] <span class="kw">where</span></span>
-<span id="cb430-8"><a href="#cb430-8" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> []</span></code></pre></div>
+<div class="sourceCode" id="cb427"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb427-1"><a href="#cb427-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> (<span class="dt">Sum</span> a) <span class="kw">where</span></span>
+<span id="cb427-2"><a href="#cb427-2" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="dt">Sum</span> <span class="dv">0</span></span>
+<span id="cb427-3"><a href="#cb427-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb427-4"><a href="#cb427-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Num</span> a <span class="ot">=&gt;</span> <span class="dt">Monoid</span> (<span class="dt">Product</span> a) <span class="kw">where</span></span>
+<span id="cb427-5"><a href="#cb427-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="dt">Product</span> <span class="dv">1</span></span>
+<span id="cb427-6"><a href="#cb427-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb427-7"><a href="#cb427-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Monoid</span> [] <span class="kw">where</span></span>
+<span id="cb427-8"><a href="#cb427-8" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> []</span></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 data-number="7.3.4" 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="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb431-1"><a href="#cb431-1" aria-hidden="true" tabindex="-1"></a><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</span></code></pre></div>
+<div class="sourceCode" id="cb428"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb428-1"><a href="#cb428-1" aria-hidden="true" tabindex="-1"></a><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</span></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="cb432"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb432-1"><a href="#cb432-1" aria-hidden="true" tabindex="-1"></a><span class="fu">mconcat</span> []<span class="ot"> ::</span> <span class="dt">Sum</span> <span class="dt">Int</span>          <span class="op">==&gt;</span>  <span class="dt">Sum</span> <span class="dv">0</span></span></code></pre></div>
+<div class="sourceCode" id="cb429"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb429-1"><a href="#cb429-1" aria-hidden="true" tabindex="-1"></a><span class="fu">mconcat</span> []<span class="ot"> ::</span> <span class="dt">Sum</span> <span class="dt">Int</span>          <span class="op">==&gt;</span>  <span class="dt">Sum</span> <span class="dv">0</span></span></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="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb433-1"><a href="#cb433-1" aria-hidden="true" tabindex="-1"></a><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</span></code></pre></div>
+<div class="sourceCode" id="cb430"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb430-1"><a href="#cb430-1" aria-hidden="true" tabindex="-1"></a><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</span></code></pre></div>
 <p>That type signature looks scary, but concrete cases are simpler:</p>
-<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb434-1"><a href="#cb434-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  <span class="dt">Max</span> <span class="dv">4</span></span>
-<span id="cb434-2"><a href="#cb434-2" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  <span class="dt">Product</span> <span class="dv">8</span></span>
-<span id="cb434-3"><a href="#cb434-3" aria-hidden="true" tabindex="-1"></a><span class="co">-- We need the ::Int to avoid an &quot;Ambiguous type variable&quot; error when printing the result</span></span></code></pre></div>
+<div class="sourceCode" id="cb431"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb431-1"><a href="#cb431-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  <span class="dt">Max</span> <span class="dv">4</span></span>
+<span id="cb431-2"><a href="#cb431-2" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  <span class="dt">Product</span> <span class="dv">8</span></span>
+<span id="cb431-3"><a href="#cb431-3" aria-hidden="true" tabindex="-1"></a><span class="co">-- We need the ::Int to avoid an &quot;Ambiguous type variable&quot; error when printing the result</span></span></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="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb435-1"><a href="#cb435-1" aria-hidden="true" tabindex="-1"></a><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</span></code></pre></div>
+<div class="sourceCode" id="cb432"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb432-1"><a href="#cb432-1" aria-hidden="true" tabindex="-1"></a><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</span></code></pre></div>
 <p>We can build this function out of functions we already know:</p>
-<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb436-1"><a href="#cb436-1" aria-hidden="true" tabindex="-1"></a>foldMap&#39; f xs <span class="ot">=</span> <span class="fu">mconcat</span> (<span class="fu">map</span> f xs)</span></code></pre></div>
+<div class="sourceCode" id="cb433"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb433-1"><a href="#cb433-1" aria-hidden="true" tabindex="-1"></a>foldMap&#39; f xs <span class="ot">=</span> <span class="fu">mconcat</span> (<span class="fu">map</span> f xs)</span></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="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb437-1"><a href="#cb437-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  (<span class="dt">Max</span> <span class="dv">4</span>, <span class="dt">Product</span> <span class="dv">8</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb434"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb434-1"><a href="#cb434-1" aria-hidden="true" tabindex="-1"></a><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="op">==&gt;</span>  (<span class="dt">Max</span> <span class="dv">4</span>, <span class="dt">Product</span> <span class="dv">8</span>)</span></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 data-number="7.3.5" 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="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb438-1"><a href="#cb438-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
-<span id="cb438-2"><a href="#cb438-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb438-3"><a href="#cb438-3" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb438-4"><a href="#cb438-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty ::</span> a</span></code></pre></div>
+<div class="sourceCode" id="cb435"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb435-1"><a href="#cb435-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
+<span id="cb435-2"><a href="#cb435-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb435-3"><a href="#cb435-3" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb435-4"><a href="#cb435-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty ::</span> a</span></code></pre></div>
 <p>Although you can mostly pretend they are. The actual definitions are:</p>
-<div class="sourceCode" id="cb439"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb439-1"><a href="#cb439-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
-<span id="cb439-2"><a href="#cb439-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- | An associative operation.</span></span>
-<span id="cb439-3"><a href="#cb439-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb439-4"><a href="#cb439-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb439-5"><a href="#cb439-5" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine elements of a nonempty list with &lt;&gt;</span></span>
-<span id="cb439-6"><a href="#cb439-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  sconcat ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb439-7"><a href="#cb439-7" aria-hidden="true" tabindex="-1"></a>  sconcat as <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span>
-<span id="cb439-8"><a href="#cb439-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb439-9"><a href="#cb439-9" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine a value with itself using &lt;&gt;, n times</span></span>
-<span id="cb439-10"><a href="#cb439-10" aria-hidden="true" tabindex="-1"></a><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</span>
-<span id="cb439-11"><a href="#cb439-11" aria-hidden="true" tabindex="-1"></a>  stimes n x <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span></code></pre></div>
-<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb440-1"><a href="#cb440-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb440-2"><a href="#cb440-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty  ::</span> a</span>
-<span id="cb440-3"><a href="#cb440-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb440-4"><a href="#cb440-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  mappend ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
-<span id="cb440-5"><a href="#cb440-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mappend</span> <span class="ot">=</span> (<span class="op">&lt;&gt;</span>)</span>
-<span id="cb440-6"><a href="#cb440-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb440-7"><a href="#cb440-7" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine elements of a list with &lt;&gt;</span></span>
-<span id="cb440-8"><a href="#cb440-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  mconcat ::</span> [a] <span class="ot">-&gt;</span> a</span>
-<span id="cb440-9"><a href="#cb440-9" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mconcat</span> <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span></code></pre></div>
+<div class="sourceCode" id="cb436"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb436-1"><a href="#cb436-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Semigroup</span> a <span class="kw">where</span></span>
+<span id="cb436-2"><a href="#cb436-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- | An associative operation.</span></span>
+<span id="cb436-3"><a href="#cb436-3" aria-hidden="true" tabindex="-1"></a><span class="ot">  (&lt;&gt;) ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb436-4"><a href="#cb436-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb436-5"><a href="#cb436-5" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine elements of a nonempty list with &lt;&gt;</span></span>
+<span id="cb436-6"><a href="#cb436-6" aria-hidden="true" tabindex="-1"></a><span class="ot">  sconcat ::</span> <span class="dt">NonEmpty</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb436-7"><a href="#cb436-7" aria-hidden="true" tabindex="-1"></a>  sconcat as <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span>
+<span id="cb436-8"><a href="#cb436-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb436-9"><a href="#cb436-9" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine a value with itself using &lt;&gt;, n times</span></span>
+<span id="cb436-10"><a href="#cb436-10" aria-hidden="true" tabindex="-1"></a><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</span>
+<span id="cb436-11"><a href="#cb436-11" aria-hidden="true" tabindex="-1"></a>  stimes n x <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span></code></pre></div>
+<div class="sourceCode" id="cb437"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb437-1"><a href="#cb437-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb437-2"><a href="#cb437-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  mempty  ::</span> a</span>
+<span id="cb437-3"><a href="#cb437-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb437-4"><a href="#cb437-4" aria-hidden="true" tabindex="-1"></a><span class="ot">  mappend ::</span> a <span class="ot">-&gt;</span> a <span class="ot">-&gt;</span> a</span>
+<span id="cb437-5"><a href="#cb437-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mappend</span> <span class="ot">=</span> (<span class="op">&lt;&gt;</span>)</span>
+<span id="cb437-6"><a href="#cb437-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb437-7"><a href="#cb437-7" aria-hidden="true" tabindex="-1"></a>  <span class="co">-- Combine elements of a list with &lt;&gt;</span></span>
+<span id="cb437-8"><a href="#cb437-8" aria-hidden="true" tabindex="-1"></a><span class="ot">  mconcat ::</span> [a] <span class="ot">-&gt;</span> a</span>
+<span id="cb437-9"><a href="#cb437-9" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mconcat</span> <span class="ot">=</span> <span class="op">...</span> <span class="co">-- default implementation omitted</span></span></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="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb441-1"><a href="#cb441-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Semigroup</span> <span class="dt">MyType</span> <span class="kw">where</span></span>
-<span id="cb441-2"><a href="#cb441-2" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;&gt;</span> y <span class="ot">=</span> <span class="op">...</span></span>
-<span id="cb441-3"><a href="#cb441-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb441-4"><a href="#cb441-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Monoid</span> <span class="dt">MyType</span> <span class="kw">where</span></span>
-<span id="cb441-5"><a href="#cb441-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="op">...</span></span></code></pre></div>
+<div class="sourceCode" id="cb438"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb438-1"><a href="#cb438-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Semigroup</span> <span class="dt">MyType</span> <span class="kw">where</span></span>
+<span id="cb438-2"><a href="#cb438-2" aria-hidden="true" tabindex="-1"></a>  x <span class="op">&lt;&gt;</span> y <span class="ot">=</span> <span class="op">...</span></span>
+<span id="cb438-3"><a href="#cb438-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb438-4"><a href="#cb438-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Monoid</span> <span class="dt">MyType</span> <span class="kw">where</span></span>
+<span id="cb438-5"><a href="#cb438-5" aria-hidden="true" tabindex="-1"></a>  <span class="fu">mempty</span> <span class="ot">=</span> <span class="op">...</span></span></code></pre></div>
 <h2 data-number="7.4" 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="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb442-1"><a href="#cb442-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Vehicle</span> <span class="ot">=</span> <span class="dt">Car</span> <span class="dt">String</span> <span class="op">|</span> <span class="dt">Airplane</span> <span class="dt">String</span></span>
-<span id="cb442-2"><a href="#cb442-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb442-3"><a href="#cb442-3" aria-hidden="true" tabindex="-1"></a><span class="ot">sound ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span>
-<span id="cb442-4"><a href="#cb442-4" aria-hidden="true" tabindex="-1"></a>sound (<span class="dt">Car</span> _) <span class="ot">=</span> <span class="st">&quot;brum brum&quot;</span></span>
-<span id="cb442-5"><a href="#cb442-5" aria-hidden="true" tabindex="-1"></a>sound (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="st">&quot;zooooom&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb439"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb439-1"><a href="#cb439-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Vehicle</span> <span class="ot">=</span> <span class="dt">Car</span> <span class="dt">String</span> <span class="op">|</span> <span class="dt">Airplane</span> <span class="dt">String</span></span>
+<span id="cb439-2"><a href="#cb439-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb439-3"><a href="#cb439-3" aria-hidden="true" tabindex="-1"></a><span class="ot">sound ::</span> <span class="dt">Vehicle</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span>
+<span id="cb439-4"><a href="#cb439-4" aria-hidden="true" tabindex="-1"></a>sound (<span class="dt">Car</span> _) <span class="ot">=</span> <span class="st">&quot;brum brum&quot;</span></span>
+<span id="cb439-5"><a href="#cb439-5" aria-hidden="true" tabindex="-1"></a>sound (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="st">&quot;zooooom&quot;</span></span></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="cb443"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb443-1"><a href="#cb443-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Car</span> <span class="ot">=</span> <span class="dt">Car</span> <span class="dt">String</span></span>
-<span id="cb443-2"><a href="#cb443-2" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Airplane</span> <span class="ot">=</span> <span class="dt">Airplane</span> <span class="dt">String</span></span>
-<span id="cb443-3"><a href="#cb443-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb443-4"><a href="#cb443-4" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">VehicleClass</span> a <span class="kw">where</span></span>
-<span id="cb443-5"><a href="#cb443-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  sound ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></span>
-<span id="cb443-6"><a href="#cb443-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb443-7"><a href="#cb443-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Car</span> <span class="kw">where</span></span>
-<span id="cb443-8"><a href="#cb443-8" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Car</span> _) <span class="ot">=</span> <span class="st">&quot;brum brum&quot;</span></span>
-<span id="cb443-9"><a href="#cb443-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb443-10"><a href="#cb443-10" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Airplane</span> <span class="kw">where</span></span>
-<span id="cb443-11"><a href="#cb443-11" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="st">&quot;zooooom&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb440"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb440-1"><a href="#cb440-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Car</span> <span class="ot">=</span> <span class="dt">Car</span> <span class="dt">String</span></span>
+<span id="cb440-2"><a href="#cb440-2" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Airplane</span> <span class="ot">=</span> <span class="dt">Airplane</span> <span class="dt">String</span></span>
+<span id="cb440-3"><a href="#cb440-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb440-4"><a href="#cb440-4" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">VehicleClass</span> a <span class="kw">where</span></span>
+<span id="cb440-5"><a href="#cb440-5" aria-hidden="true" tabindex="-1"></a><span class="ot">  sound ::</span> a <span class="ot">-&gt;</span> <span class="dt">String</span></span>
+<span id="cb440-6"><a href="#cb440-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb440-7"><a href="#cb440-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Car</span> <span class="kw">where</span></span>
+<span id="cb440-8"><a href="#cb440-8" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Car</span> _) <span class="ot">=</span> <span class="st">&quot;brum brum&quot;</span></span>
+<span id="cb440-9"><a href="#cb440-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb440-10"><a href="#cb440-10" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Airplane</span> <span class="kw">where</span></span>
+<span id="cb440-11"><a href="#cb440-11" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="st">&quot;zooooom&quot;</span></span></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="cb444"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb444-1"><a href="#cb444-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Bike</span> <span class="ot">=</span> <span class="dt">Bike</span> <span class="dt">String</span></span>
-<span id="cb444-2"><a href="#cb444-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb444-3"><a href="#cb444-3" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Bike</span> <span class="kw">where</span></span>
-<span id="cb444-4"><a href="#cb444-4" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Bike</span> _) <span class="ot">=</span> <span class="st">&quot;whirrr&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb441"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb441-1"><a href="#cb441-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Bike</span> <span class="ot">=</span> <span class="dt">Bike</span> <span class="dt">String</span></span>
+<span id="cb441-2"><a href="#cb441-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb441-3"><a href="#cb441-3" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">VehicleClass</span> <span class="dt">Bike</span> <span class="kw">where</span></span>
+<span id="cb441-4"><a href="#cb441-4" aria-hidden="true" tabindex="-1"></a>  sound (<span class="dt">Bike</span> _) <span class="ot">=</span> <span class="st">&quot;whirrr&quot;</span></span></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="cb445"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb445-1"><a href="#cb445-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb445-2"><a href="#cb445-2" aria-hidden="true" tabindex="-1"></a>canCollide (<span class="dt">Car</span> _)      (<span class="dt">Car</span> _)      <span class="ot">=</span> <span class="dt">True</span></span>
-<span id="cb445-3"><a href="#cb445-3" aria-hidden="true" tabindex="-1"></a>canCollide (<span class="dt">Airplane</span> _) (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="dt">True</span></span>
-<span id="cb445-4"><a href="#cb445-4" aria-hidden="true" tabindex="-1"></a>canCollide _            _            <span class="ot">=</span> <span class="dt">False</span></span></code></pre></div>
+<div class="sourceCode" id="cb442"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb442-1"><a href="#cb442-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb442-2"><a href="#cb442-2" aria-hidden="true" tabindex="-1"></a>canCollide (<span class="dt">Car</span> _)      (<span class="dt">Car</span> _)      <span class="ot">=</span> <span class="dt">True</span></span>
+<span id="cb442-3"><a href="#cb442-3" aria-hidden="true" tabindex="-1"></a>canCollide (<span class="dt">Airplane</span> _) (<span class="dt">Airplane</span> _) <span class="ot">=</span> <span class="dt">True</span></span>
+<span id="cb442-4"><a href="#cb442-4" aria-hidden="true" tabindex="-1"></a>canCollide _            _            <span class="ot">=</span> <span class="dt">False</span></span></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 data-number="7.5" 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="cb446"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb446-1"><a href="#cb446-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Discount</span> <span class="ot">=</span> <span class="dt">DiscountPercent</span> <span class="dt">Int</span>         <span class="co">-- A percentage discount</span></span>
-<span id="cb446-2"><a href="#cb446-2" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">DiscountConstant</span> <span class="dt">Int</span>        <span class="co">-- A constant discount</span></span>
-<span id="cb446-3"><a href="#cb446-3" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">MinimumPrice</span> <span class="dt">Int</span>            <span class="co">-- Set a minimum price</span></span>
-<span id="cb446-4"><a href="#cb446-4" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">ForCustomer</span> <span class="dt">String</span> <span class="dt">Discount</span> <span class="co">-- Discounts can be conditional</span></span>
-<span id="cb446-5"><a href="#cb446-5" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">Many</span> [<span class="dt">Discount</span>]             <span class="co">-- Apply a number of discounts in row</span></span></code></pre></div>
+<div class="sourceCode" id="cb443"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb443-1"><a href="#cb443-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Discount</span> <span class="ot">=</span> <span class="dt">DiscountPercent</span> <span class="dt">Int</span>         <span class="co">-- A percentage discount</span></span>
+<span id="cb443-2"><a href="#cb443-2" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">DiscountConstant</span> <span class="dt">Int</span>        <span class="co">-- A constant discount</span></span>
+<span id="cb443-3"><a href="#cb443-3" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">MinimumPrice</span> <span class="dt">Int</span>            <span class="co">-- Set a minimum price</span></span>
+<span id="cb443-4"><a href="#cb443-4" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">ForCustomer</span> <span class="dt">String</span> <span class="dt">Discount</span> <span class="co">-- Discounts can be conditional</span></span>
+<span id="cb443-5"><a href="#cb443-5" aria-hidden="true" tabindex="-1"></a>              <span class="op">|</span> <span class="dt">Many</span> [<span class="dt">Discount</span>]             <span class="co">-- Apply a number of discounts in row</span></span></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="cb447"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb447-1"><a href="#cb447-1" aria-hidden="true" tabindex="-1"></a><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></span>
-<span id="cb447-2"><a href="#cb447-2" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">DiscountPercent</span> percent) <span class="ot">=</span> price <span class="op">-</span> (price <span class="op">*</span> percent) <span class="ot">`div`</span> <span class="dv">100</span></span>
-<span id="cb447-3"><a href="#cb447-3" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">DiscountConstant</span> discount) <span class="ot">=</span> price <span class="op">-</span> discount</span>
-<span id="cb447-4"><a href="#cb447-4" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">MinimumPrice</span> minPrice) <span class="ot">=</span> <span class="fu">max</span> price minPrice</span>
-<span id="cb447-5"><a href="#cb447-5" aria-hidden="true" tabindex="-1"></a>applyDiscount customer price (<span class="dt">ForCustomer</span> target discount)</span>
-<span id="cb447-6"><a href="#cb447-6" aria-hidden="true" tabindex="-1"></a>    <span class="op">|</span> customer <span class="op">==</span> target  <span class="ot">=</span> applyDiscount customer price discount</span>
-<span id="cb447-7"><a href="#cb447-7" aria-hidden="true" tabindex="-1"></a>    <span class="op">|</span> <span class="fu">otherwise</span>           <span class="ot">=</span> price</span>
-<span id="cb447-8"><a href="#cb447-8" aria-hidden="true" tabindex="-1"></a>applyDiscount customer price (<span class="dt">Many</span> discounts) <span class="ot">=</span> go price discounts</span>
-<span id="cb447-9"><a href="#cb447-9" aria-hidden="true" tabindex="-1"></a>  <span class="kw">where</span> go p [] <span class="ot">=</span> p</span>
-<span id="cb447-10"><a href="#cb447-10" aria-hidden="true" tabindex="-1"></a>        go p (d<span class="op">:</span>ds) <span class="ot">=</span> go (applyDiscount customer p d) ds</span></code></pre></div>
+<div class="sourceCode" id="cb444"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb444-1"><a href="#cb444-1" aria-hidden="true" tabindex="-1"></a><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></span>
+<span id="cb444-2"><a href="#cb444-2" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">DiscountPercent</span> percent) <span class="ot">=</span> price <span class="op">-</span> (price <span class="op">*</span> percent) <span class="ot">`div`</span> <span class="dv">100</span></span>
+<span id="cb444-3"><a href="#cb444-3" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">DiscountConstant</span> discount) <span class="ot">=</span> price <span class="op">-</span> discount</span>
+<span id="cb444-4"><a href="#cb444-4" aria-hidden="true" tabindex="-1"></a>applyDiscount _        price (<span class="dt">MinimumPrice</span> minPrice) <span class="ot">=</span> <span class="fu">max</span> price minPrice</span>
+<span id="cb444-5"><a href="#cb444-5" aria-hidden="true" tabindex="-1"></a>applyDiscount customer price (<span class="dt">ForCustomer</span> target discount)</span>
+<span id="cb444-6"><a href="#cb444-6" aria-hidden="true" tabindex="-1"></a>    <span class="op">|</span> customer <span class="op">==</span> target  <span class="ot">=</span> applyDiscount customer price discount</span>
+<span id="cb444-7"><a href="#cb444-7" aria-hidden="true" tabindex="-1"></a>    <span class="op">|</span> <span class="fu">otherwise</span>           <span class="ot">=</span> price</span>
+<span id="cb444-8"><a href="#cb444-8" aria-hidden="true" tabindex="-1"></a>applyDiscount customer price (<span class="dt">Many</span> discounts) <span class="ot">=</span> go price discounts</span>
+<span id="cb444-9"><a href="#cb444-9" aria-hidden="true" tabindex="-1"></a>  <span class="kw">where</span> go p [] <span class="ot">=</span> p</span>
+<span id="cb444-10"><a href="#cb444-10" aria-hidden="true" tabindex="-1"></a>        go p (d<span class="op">:</span>ds) <span class="ot">=</span> go (applyDiscount customer p d) ds</span></code></pre></div>
 <p>Here we apply a discount chain of -50%, -$30 with a minimum price of $35:</p>
-<div class="sourceCode" id="cb448"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb448-1"><a href="#cb448-1" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">DiscountPercent</span> <span class="dv">50</span>)</span>
-<span id="cb448-2"><a href="#cb448-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">60</span></span>
-<span id="cb448-3"><a href="#cb448-3" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">60</span> (<span class="dt">DiscountConstant</span> <span class="dv">30</span>)</span>
-<span id="cb448-4"><a href="#cb448-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">30</span></span>
-<span id="cb448-5"><a href="#cb448-5" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span> (<span class="dt">MinimumPrice</span> <span class="dv">35</span>)</span>
-<span id="cb448-6"><a href="#cb448-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">35</span></span>
-<span id="cb448-7"><a href="#cb448-7" aria-hidden="true" tabindex="-1"></a>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>])</span>
-<span id="cb448-8"><a href="#cb448-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">35</span></span></code></pre></div>
+<div class="sourceCode" id="cb445"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb445-1"><a href="#cb445-1" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">120</span> (<span class="dt">DiscountPercent</span> <span class="dv">50</span>)</span>
+<span id="cb445-2"><a href="#cb445-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">60</span></span>
+<span id="cb445-3"><a href="#cb445-3" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">60</span> (<span class="dt">DiscountConstant</span> <span class="dv">30</span>)</span>
+<span id="cb445-4"><a href="#cb445-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">30</span></span>
+<span id="cb445-5"><a href="#cb445-5" aria-hidden="true" tabindex="-1"></a>applyDiscount <span class="st">&quot;Bob&quot;</span> <span class="dv">30</span> (<span class="dt">MinimumPrice</span> <span class="dv">35</span>)</span>
+<span id="cb445-6"><a href="#cb445-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">35</span></span>
+<span id="cb445-7"><a href="#cb445-7" aria-hidden="true" tabindex="-1"></a>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>])</span>
+<span id="cb445-8"><a href="#cb445-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">35</span></span></code></pre></div>
 <p>Here we have different discounts for Ssarah and Yvonne:</p>
-<div class="sourceCode" id="cb449"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb449-1"><a href="#cb449-1" aria-hidden="true" tabindex="-1"></a>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>)])</span>
-<span id="cb449-2"><a href="#cb449-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">90</span></span>
-<span id="cb449-3"><a href="#cb449-3" aria-hidden="true" tabindex="-1"></a>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>)])</span>
-<span id="cb449-4"><a href="#cb449-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">80</span></span></code></pre></div>
+<div class="sourceCode" id="cb446"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb446-1"><a href="#cb446-1" aria-hidden="true" tabindex="-1"></a>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>)])</span>
+<span id="cb446-2"><a href="#cb446-2" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">90</span></span>
+<span id="cb446-3"><a href="#cb446-3" aria-hidden="true" tabindex="-1"></a>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>)])</span>
+<span id="cb446-4"><a href="#cb446-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">==&gt;</span> <span class="dv">80</span></span></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 -->
@@ -3982,103 +3959,103 @@ If I define an instance for <code>Num</code>, I also get an instance for <code>F
 <h2 data-number="8.1" 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="cb450"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb450-1"><a href="#cb450-1" aria-hidden="true" tabindex="-1"></a><span class="ot">readInputFromTheUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span></code></pre></div>
+<div class="sourceCode" id="cb447"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb447-1"><a href="#cb447-1" aria-hidden="true" tabindex="-1"></a><span class="ot">readInputFromTheUser ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span></span></code></pre></div>
 <p>can’t be pure, because if it were, <code>readInputFromUser "What is your name?"</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="cb451"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb451-1"><a href="#cb451-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">getLine</span></span>
-<span id="cb451-2"><a href="#cb451-2" aria-hidden="true" tabindex="-1"></a><span class="fu">getLine</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></span>
-<span id="cb451-3"><a href="#cb451-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> line <span class="ot">&lt;-</span> <span class="fu">getLine</span></span></code></pre></div>
+<div class="sourceCode" id="cb448"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb448-1"><a href="#cb448-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">getLine</span></span>
+<span id="cb448-2"><a href="#cb448-2" aria-hidden="true" tabindex="-1"></a><span class="fu">getLine</span><span class="ot"> ::</span> <span class="dt">IO</span> <span class="dt">String</span></span>
+<span id="cb448-3"><a href="#cb448-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> line <span class="ot">&lt;-</span> <span class="fu">getLine</span></span></code></pre></div>
 <pre><code>another line</code></pre>
-<div class="sourceCode" id="cb453"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb453-1"><a href="#cb453-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t line</span>
-<span id="cb453-2"><a href="#cb453-2" aria-hidden="true" tabindex="-1"></a><span class="ot">line ::</span> <span class="dt">String</span></span>
-<span id="cb453-3"><a href="#cb453-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> line</span>
-<span id="cb453-4"><a href="#cb453-4" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;another line&quot;</span></span>
-<span id="cb453-5"><a href="#cb453-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">reverse</span> line</span>
-<span id="cb453-6"><a href="#cb453-6" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;enil rehtona&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb450"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb450-1"><a href="#cb450-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t line</span>
+<span id="cb450-2"><a href="#cb450-2" aria-hidden="true" tabindex="-1"></a><span class="ot">line ::</span> <span class="dt">String</span></span>
+<span id="cb450-3"><a href="#cb450-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> line</span>
+<span id="cb450-4"><a href="#cb450-4" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;another line&quot;</span></span>
+<span id="cb450-5"><a href="#cb450-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">reverse</span> line</span>
+<span id="cb450-6"><a href="#cb450-6" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;enil rehtona&quot;</span></span></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="cb454"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb454-1"><a href="#cb454-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">putStrLn</span></span>
-<span id="cb454-2"><a href="#cb454-2" aria-hidden="true" tabindex="-1"></a><span class="fu">putStrLn</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</span>
-<span id="cb454-3"><a href="#cb454-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
-<span id="cb454-4"><a href="#cb454-4" aria-hidden="true" tabindex="-1"></a><span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> ()</span>
-<span id="cb454-5"><a href="#cb454-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> val <span class="ot">&lt;-</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
-<span id="cb454-6"><a href="#cb454-6" aria-hidden="true" tabindex="-1"></a>hello</span>
-<span id="cb454-7"><a href="#cb454-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> val</span>
-<span id="cb454-8"><a href="#cb454-8" aria-hidden="true" tabindex="-1"></a>()</span></code></pre></div>
+<div class="sourceCode" id="cb451"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb451-1"><a href="#cb451-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">putStrLn</span></span>
+<span id="cb451-2"><a href="#cb451-2" aria-hidden="true" tabindex="-1"></a><span class="fu">putStrLn</span><span class="ot"> ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> ()</span>
+<span id="cb451-3"><a href="#cb451-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</span>t <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
+<span id="cb451-4"><a href="#cb451-4" aria-hidden="true" tabindex="-1"></a><span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span><span class="ot"> ::</span> <span class="dt">IO</span> ()</span>
+<span id="cb451-5"><a href="#cb451-5" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> val <span class="ot">&lt;-</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
+<span id="cb451-6"><a href="#cb451-6" aria-hidden="true" tabindex="-1"></a>hello</span>
+<span id="cb451-7"><a href="#cb451-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> val</span>
+<span id="cb451-8"><a href="#cb451-8" aria-hidden="true" tabindex="-1"></a>()</span></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="cb455"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb455-1"><a href="#cb455-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
-<span id="cb455-2"><a href="#cb455-2" aria-hidden="true" tabindex="-1"></a>hello</span></code></pre></div>
+<div class="sourceCode" id="cb452"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb452-1"><a href="#cb452-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">putStrLn</span> <span class="st">&quot;hello&quot;</span></span>
+<span id="cb452-2"><a href="#cb452-2" aria-hidden="true" tabindex="-1"></a>hello</span></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="cb456"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb456-1"><a href="#cb456-1" aria-hidden="true" tabindex="-1"></a><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</span>
-<span id="cb456-2"><a href="#cb456-2" aria-hidden="true" tabindex="-1"></a>printTwoThings <span class="ot">=</span> <span class="kw">do</span></span>
-<span id="cb456-3"><a href="#cb456-3" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;Hello!&quot;</span></span>
-<span id="cb456-4"><a href="#cb456-4" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;How are you?&quot;</span></span>
-<span id="cb456-5"><a href="#cb456-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb456-6"><a href="#cb456-6" aria-hidden="true" tabindex="-1"></a><span class="ot">greet ::</span> <span class="dt">IO</span> ()</span>
-<span id="cb456-7"><a href="#cb456-7" aria-hidden="true" tabindex="-1"></a>greet <span class="ot">=</span> <span class="kw">do</span></span>
-<span id="cb456-8"><a href="#cb456-8" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;What&#39;s your name?&quot;</span></span>
-<span id="cb456-9"><a href="#cb456-9" aria-hidden="true" tabindex="-1"></a>  name <span class="ot">&lt;-</span> <span class="fu">getLine</span></span>
-<span id="cb456-10"><a href="#cb456-10" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> (<span class="st">&quot;Hello, &quot;</span> <span class="op">++</span> name)</span></code></pre></div>
-<div class="sourceCode" id="cb457"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb457-1"><a href="#cb457-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> printTwoThings</span>
-<span id="cb457-2"><a href="#cb457-2" aria-hidden="true" tabindex="-1"></a><span class="dt">Hello</span><span class="op">!</span></span>
-<span id="cb457-3"><a href="#cb457-3" aria-hidden="true" tabindex="-1"></a><span class="dt">How</span> are you<span class="op">?</span></span>
-<span id="cb457-4"><a href="#cb457-4" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> greet</span>
-<span id="cb457-5"><a href="#cb457-5" aria-hidden="true" tabindex="-1"></a><span class="dt">What&#39;s</span> your name<span class="op">?</span></span>
-<span id="cb457-6"><a href="#cb457-6" aria-hidden="true" tabindex="-1"></a><span class="dt">Seraphim</span></span>
-<span id="cb457-7"><a href="#cb457-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Hello</span>, <span class="dt">Seraphim</span></span></code></pre></div>
+<div class="sourceCode" id="cb453"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb453-1"><a href="#cb453-1" aria-hidden="true" tabindex="-1"></a><span class="ot">printTwoThings ::</span> <span class="dt">IO</span> ()</span>
+<span id="cb453-2"><a href="#cb453-2" aria-hidden="true" tabindex="-1"></a>printTwoThings <span class="ot">=</span> <span class="kw">do</span></span>
+<span id="cb453-3"><a href="#cb453-3" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;Hello!&quot;</span></span>
+<span id="cb453-4"><a href="#cb453-4" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;How are you?&quot;</span></span>
+<span id="cb453-5"><a href="#cb453-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb453-6"><a href="#cb453-6" aria-hidden="true" tabindex="-1"></a><span class="ot">greet ::</span> <span class="dt">IO</span> ()</span>
+<span id="cb453-7"><a href="#cb453-7" aria-hidden="true" tabindex="-1"></a>greet <span class="ot">=</span> <span class="kw">do</span></span>
+<span id="cb453-8"><a href="#cb453-8" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> <span class="st">&quot;What&#39;s your name?&quot;</span></span>
+<span id="cb453-9"><a href="#cb453-9" aria-hidden="true" tabindex="-1"></a>  name <span class="ot">&lt;-</span> <span class="fu">getLine</span></span>
+<span id="cb453-10"><a href="#cb453-10" aria-hidden="true" tabindex="-1"></a>  <span class="fu">putStrLn</span> (<span class="st">&quot;Hello, &quot;</span> <span class="op">++</span> name)</span></code></pre></div>
+<div class="sourceCode" id="cb454"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb454-1"><a href="#cb454-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> printTwoThings</span>
+<span id="cb454-2"><a href="#cb454-2" aria-hidden="true" tabindex="-1"></a><span class="dt">Hello</span><span class="op">!</span></span>
+<span id="cb454-3"><a href="#cb454-3" aria-hidden="true" tabindex="-1"></a><span class="dt">How</span> are you<span class="op">?</span></span>
+<span id="cb454-4"><a href="#cb454-4" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> greet</span>
+<span id="cb454-5"><a href="#cb454-5" aria-hidden="true" tabindex="-1"></a><span class="dt">What&#39;s</span> your name<span class="op">?</span></span>
+<span id="cb454-6"><a href="#cb454-6" aria-hidden="true" tabindex="-1"></a><span class="dt">Seraphim</span></span>
+<span id="cb454-7"><a href="#cb454-7" aria-hidden="true" tabindex="-1"></a><span class="dt">Hello</span>, <span class="dt">Seraphim</span></span></code></pre></div>
 <h3 data-number="8.1.1" 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="cb458"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb458-1"><a href="#cb458-1" aria-hidden="true" tabindex="-1"></a><span class="ot">printAndIncrement ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
-<span id="cb458-2"><a href="#cb458-2" aria-hidden="true" tabindex="-1"></a>printAndIncrement x <span class="ot">=</span> x<span class="op">+</span><span class="dv">1</span></span>
-<span id="cb458-3"><a href="#cb458-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">where</span> action <span class="ot">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;got a number!&quot;</span></span></code></pre></div>
-<div class="sourceCode" id="cb459"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb459-1"><a href="#cb459-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">map</span> printAndIncrement [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</span>
-<span id="cb459-2"><a href="#cb459-2" aria-hidden="true" tabindex="-1"></a>[<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span></code></pre></div>
+<div class="sourceCode" id="cb455"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb455-1"><a href="#cb455-1" aria-hidden="true" tabindex="-1"></a><span class="ot">printAndIncrement ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">Int</span></span>
+<span id="cb455-2"><a href="#cb455-2" aria-hidden="true" tabindex="-1"></a>printAndIncrement x <span class="ot">=</span> x<span class="op">+</span><span class="dv">1</span></span>
+<span id="cb455-3"><a href="#cb455-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">where</span> action <span class="ot">=</span> <span class="fu">putStrLn</span> <span class="st">&quot;got a number!&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb456"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb456-1"><a href="#cb456-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="fu">map</span> printAndIncrement [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]</span>
+<span id="cb456-2"><a href="#cb456-2" aria-hidden="true" tabindex="-1"></a>[<span class="dv">2</span>,<span class="dv">3</span>,<span class="dv">4</span>]</span></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="cb460"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb460-1"><a href="#cb460-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&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>])</span>
-<span id="cb460-2"><a href="#cb460-2" aria-hidden="true" tabindex="-1"></a><span class="dv">2</span></span></code></pre></div>
+<div class="sourceCode" id="cb457"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb457-1"><a href="#cb457-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&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>])</span>
+<span id="cb457-2"><a href="#cb457-2" aria-hidden="true" tabindex="-1"></a><span class="dv">2</span></span></code></pre></div>
 <p>That didn’t print anything either! Let’s see why:</p>
-<div class="sourceCode" id="cb461"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb461-1"><a href="#cb461-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>]</span>
-<span id="cb461-2"><a href="#cb461-2" aria-hidden="true" tabindex="-1"></a><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> ()]</span>
-<span id="cb461-3"><a href="#cb461-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>])</span>
-<span id="cb461-4"><a href="#cb461-4" aria-hidden="true" tabindex="-1"></a><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></span></code></pre></div>
+<div class="sourceCode" id="cb458"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb458-1"><a href="#cb458-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>]</span>
+<span id="cb458-2"><a href="#cb458-2" aria-hidden="true" tabindex="-1"></a><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> ()]</span>
+<span id="cb458-3"><a href="#cb458-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>])</span>
+<span id="cb458-4"><a href="#cb458-4" aria-hidden="true" tabindex="-1"></a><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></span></code></pre></div>
 <p>We generated a list of IO actions and computed the length 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="cb462"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb462-1"><a href="#cb462-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>])</span>
-<span id="cb462-2"><a href="#cb462-2" aria-hidden="true" tabindex="-1"></a><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> ()</span>
-<span id="cb462-3"><a href="#cb462-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&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>])</span>
-<span id="cb462-4"><a href="#cb462-4" aria-hidden="true" tabindex="-1"></a>string1</span></code></pre></div>
+<div class="sourceCode" id="cb459"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb459-1"><a href="#cb459-1" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&gt;</span> <span class="op">:</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>])</span>
+<span id="cb459-2"><a href="#cb459-2" aria-hidden="true" tabindex="-1"></a><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> ()</span>
+<span id="cb459-3"><a href="#cb459-3" aria-hidden="true" tabindex="-1"></a><span class="dt">Prelude</span><span class="op">&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>])</span>
+<span id="cb459-4"><a href="#cb459-4" aria-hidden="true" tabindex="-1"></a>string1</span></code></pre></div>
 <p>Here too, the code that produces the action <code>putStrLn "string1"</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 "string2"</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 data-number="8.1.2" 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="cb463"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb463-1"><a href="#cb463-1" aria-hidden="true" tabindex="-1"></a><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></span>
-<span id="cb463-2"><a href="#cb463-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb463-3"><a href="#cb463-3" aria-hidden="true" tabindex="-1"></a><span class="co">-- The golden ratio</span></span>
-<span id="cb463-4"><a href="#cb463-4" aria-hidden="true" tabindex="-1"></a><span class="ot">phi ::</span> <span class="dt">Double</span></span>
-<span id="cb463-5"><a href="#cb463-5" aria-hidden="true" tabindex="-1"></a>phi <span class="ot">=</span> (<span class="fu">sqrt</span> <span class="dv">5</span> <span class="op">+</span> <span class="dv">1</span>) <span class="op">/</span> <span class="dv">2</span></span>
-<span id="cb463-6"><a href="#cb463-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb463-7"><a href="#cb463-7" aria-hidden="true" tabindex="-1"></a><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></span>
-<span id="cb463-8"><a href="#cb463-8" aria-hidden="true" tabindex="-1"></a>polynomial x <span class="ot">=</span> x<span class="op">^</span><span class="dv">2</span> <span class="op">-</span> x <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb463-9"><a href="#cb463-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb463-10"><a href="#cb463-10" aria-hidden="true" tabindex="-1"></a>f x <span class="ot">=</span> polynomial (polynomial x)</span>
-<span id="cb463-11"><a href="#cb463-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb463-12"><a href="#cb463-12" aria-hidden="true" tabindex="-1"></a>main <span class="ot">=</span> <span class="kw">do</span></span>
-<span id="cb463-13"><a href="#cb463-13" aria-hidden="true" tabindex="-1"></a>  <span class="fu">print</span> (polynomial phi)</span>
-<span id="cb463-14"><a href="#cb463-14" aria-hidden="true" tabindex="-1"></a>  <span class="fu">print</span> (f phi)</span></code></pre></div>
+<div class="sourceCode" id="cb460"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb460-1"><a href="#cb460-1" aria-hidden="true" tabindex="-1"></a><span class="kw">module</span> <span class="dt">Gold</span> <span class="kw">where</span></span>
+<span id="cb460-2"><a href="#cb460-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb460-3"><a href="#cb460-3" aria-hidden="true" tabindex="-1"></a><span class="co">-- The golden ratio</span></span>
+<span id="cb460-4"><a href="#cb460-4" aria-hidden="true" tabindex="-1"></a><span class="ot">phi ::</span> <span class="dt">Double</span></span>
+<span id="cb460-5"><a href="#cb460-5" aria-hidden="true" tabindex="-1"></a>phi <span class="ot">=</span> (<span class="fu">sqrt</span> <span class="dv">5</span> <span class="op">+</span> <span class="dv">1</span>) <span class="op">/</span> <span class="dv">2</span></span>
+<span id="cb460-6"><a href="#cb460-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb460-7"><a href="#cb460-7" aria-hidden="true" tabindex="-1"></a><span class="ot">polynomial ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">Double</span></span>
+<span id="cb460-8"><a href="#cb460-8" aria-hidden="true" tabindex="-1"></a>polynomial x <span class="ot">=</span> x<span class="op">^</span><span class="dv">2</span> <span class="op">-</span> x <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb460-9"><a href="#cb460-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb460-10"><a href="#cb460-10" aria-hidden="true" tabindex="-1"></a>f x <span class="ot">=</span> polynomial (polynomial x)</span>
+<span id="cb460-11"><a href="#cb460-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb460-12"><a href="#cb460-12" aria-hidden="true" tabindex="-1"></a>main <span class="ot">=</span> <span class="kw">do</span></span>
+<span id="cb460-13"><a href="#cb460-13" aria-hidden="true" tabindex="-1"></a>  <span class="fu">print</span> (polynomial phi)</span>
+<span id="cb460-14"><a href="#cb460-14" aria-hidden="true" tabindex="-1"></a>  <span class="fu">print</span> (f phi)</span></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="cb464"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb464-1"><a href="#cb464-1" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> ghc <span class="at">-main-is</span> Gold Gold.hs</span>
-<span id="cb464-2"><a href="#cb464-2" aria-hidden="true" tabindex="-1"></a><span class="ex">[1</span> of 1] Compiling Gold             <span class="er">(</span> <span class="ex">Gold.hs,</span> Gold.o <span class="kw">)</span></span>
-<span id="cb464-3"><a href="#cb464-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Linking</span> Gold ...</span>
-<span id="cb464-4"><a href="#cb464-4" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> ./Gold</span>
-<span id="cb464-5"><a href="#cb464-5" aria-hidden="true" tabindex="-1"></a><span class="ex">0.0</span></span>
-<span id="cb464-6"><a href="#cb464-6" aria-hidden="true" tabindex="-1"></a><span class="ex">-1.0</span></span></code></pre></div>
+<div class="sourceCode" id="cb461"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb461-1"><a href="#cb461-1" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> ghc <span class="at">-main-is</span> Gold Gold.hs</span>
+<span id="cb461-2"><a href="#cb461-2" aria-hidden="true" tabindex="-1"></a><span class="ex">[1</span> of 1] Compiling Gold             <span class="er">(</span> <span class="ex">Gold.hs,</span> Gold.o <span class="kw">)</span></span>
+<span id="cb461-3"><a href="#cb461-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Linking</span> Gold ...</span>
+<span id="cb461-4"><a href="#cb461-4" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> ./Gold</span>
+<span id="cb461-5"><a href="#cb461-5" aria-hidden="true" tabindex="-1"></a><span class="ex">0.0</span></span>
+<span id="cb461-6"><a href="#cb461-6" aria-hidden="true" tabindex="-1"></a><span class="ex">-1.0</span></span></code></pre></div>
 <h2 data-number="8.2" 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>