From 58db6e0355fe5a2bf25ff5705512acaf25c036e4 Mon Sep 17 00:00:00 2001
From: hanjoosten <han.joosten@ordina.nl>
Date: Sun, 10 Mar 2024 11:53:09 +0100
Subject: [PATCH] Add Either type (error handling)

---
 index.html              | 132 +++++++++++++++++++++++++++++++---------
 slides/slidesEnglish.md |  49 ++++++++++++++-
 2 files changed, 151 insertions(+), 30 deletions(-)

diff --git a/index.html b/index.html
index 12f5130..c28b23e 100644
--- a/index.html
+++ b/index.html
@@ -35,7 +35,7 @@
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   <meta http-equiv="Content-Style-Type" content="text/css" />
   <meta name="generator" content="pandoc" />
-  <meta name="author" content="Han Joosten &amp; Daniel Lau" />
+  <meta name="author" content="Han Joosten &amp; Dan Lau" />
   <meta name="date" content="2024-03-11" />
   <title>Haskell: Functional Programming</title>
   <style type="text/css">
@@ -115,7 +115,7 @@
 <div class="slide titlepage">
   <h1 class="title">Haskell: Functional Programming</h1>
   <p class="author">
-Han Joosten &amp; Daniel Lau
+Han Joosten &amp; Dan Lau
   </p>
   <p class="date">2024-03-11</p>
 </div>
@@ -132,7 +132,7 @@ <h1>Welcome!</h1>
 <h1>Slides</h1>
 <pre><code>https://hanjoosten.github.io/HaskellWorkshop</code></pre>
 <ul>
-<li>Suited for workshop AND self-learning</li>
+<li>Crafted for both workshop AND self-learning</li>
 <li>forked from <a href="https://github.com/bos/strange-loop-2011">Bryan O’Sullivan</a></li>
 </ul>
 </div>
@@ -155,8 +155,31 @@ <h1>Han’s background in (functional) programming</h1>
 <li>The community of people is amazing</li>
 </ul>
 </div>
-<div id="what-to-expect-1" class="slide section level1">
-<h1>What to expect 1</h1>
+<div id="dans-background" class="slide section level1">
+<h1>Dan’s background</h1>
+<ul>
+<li>4 year old Scala developer</li>
+<li>previously 4 years data science &amp; econometrics (in R, also FP, without knowing it)</li>
+<li>In 4 Ordina assignments, teams are FP. Current teammates learning Rust. Deploying blockchain</li>
+<li>Completed LG1 last year and facilitated LG2 FP in Elm</li>
+<li>Reactive experience with Akka actors (JVM)</li>
+<li>Kotlin developer Thom van Kalkeren (Codestar) joins tomorrow</li>
+</ul>
+</div>
+<div id="discuss" class="slide section level1">
+<h1>Discuss</h1>
+<ul>
+<li>What is Functional Programming</li>
+<li>What are your experiences? Why FP?</li>
+<li>Do you share some common reactions</li>
+<li>Good use cases for FP</li>
+<li>Where FP not useful</li>
+<li>Trends and architectures where FP plays a role</li>
+</ul>
+<p>Form groups of 3 to a whiteboard/flipboard, and write down some answers. We will then go from board to board, and another group will try to riff on what you have written on your board</p>
+</div>
+<div id="workshop-what-to-expect-1" class="slide section level1">
+<h1>Workshop: What to expect 1</h1>
 <ul>
 <li>Haskell is a fairly big language</li>
 <li>Since so much is unfamiliar to newcomers, expect to wander far from your comfort zone</li>
@@ -685,7 +708,7 @@ <h1>Adding dependencies</h1>
   - base &gt;= 4.7 &amp;&amp; &lt; 5
   - http-conduit</code></pre>
 <p>The next time you build your program, it figures out all the other libraries that <code>http-conduit</code> depends on, and downloads, compiles, and installs the whole lot.</p>
-<p>Now also add the following dependencies, for you will need them later as well:</p>
+<p>While we are at it, also add the following dependencies, for you will need them later as well:</p>
 <pre><code>  - bytestring
   - utf8-string
   - tagsoup
@@ -1319,12 +1342,47 @@ <h1>We’re there!</h1>
 <p>Hoover over the blue line, select the blue dot and <code>apply hint &quot;use mapMaybe&quot;</code></p>
 <div class="sourceCode" id="cb118"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true"></a><span class="ot">links ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> [<span class="dt">String</span>]</span>
 <span id="cb118-2"><a href="#cb118-2" aria-hidden="true"></a>links url <span class="ot">=</span></span>
-<span id="cb118-3"><a href="#cb118-3" aria-hidden="true"></a>    mapMaybe (canonicalizeLink url) <span class="op">.</span> <span class="fu">filter</span> (<span class="fu">not</span> <span class="op">.</span> <span class="fu">null</span>) <span class="op">.</span></span>
-<span id="cb118-4"><a href="#cb118-4" aria-hidden="true"></a>    <span class="fu">map</span> (fromAttrib <span class="st">&quot;href&quot;</span>) <span class="op">.</span></span>
-<span id="cb118-5"><a href="#cb118-5" aria-hidden="true"></a>    <span class="fu">filter</span> (<span class="fu">not</span> <span class="op">.</span> nofollow) <span class="op">.</span></span>
-<span id="cb118-6"><a href="#cb118-6" aria-hidden="true"></a>    <span class="fu">filter</span> (isTagOpenName <span class="st">&quot;a&quot;</span>) <span class="op">.</span></span>
-<span id="cb118-7"><a href="#cb118-7" aria-hidden="true"></a>    canonicalizeTags <span class="op">.</span></span>
-<span id="cb118-8"><a href="#cb118-8" aria-hidden="true"></a>    parseTags</span></code></pre></div>
+<span id="cb118-3"><a href="#cb118-3" aria-hidden="true"></a>    mapMaybe (canonicalizeLink url) <span class="op">.</span> </span>
+<span id="cb118-4"><a href="#cb118-4" aria-hidden="true"></a>    <span class="fu">filter</span> (<span class="fu">not</span> <span class="op">.</span> <span class="fu">null</span>) <span class="op">.</span></span>
+<span id="cb118-5"><a href="#cb118-5" aria-hidden="true"></a>    <span class="fu">map</span> (fromAttrib <span class="st">&quot;href&quot;</span>) <span class="op">.</span></span>
+<span id="cb118-6"><a href="#cb118-6" aria-hidden="true"></a>    <span class="fu">filter</span> (<span class="fu">not</span> <span class="op">.</span> nofollow) <span class="op">.</span></span>
+<span id="cb118-7"><a href="#cb118-7" aria-hidden="true"></a>    <span class="fu">filter</span> (isTagOpenName <span class="st">&quot;a&quot;</span>) <span class="op">.</span></span>
+<span id="cb118-8"><a href="#cb118-8" aria-hidden="true"></a>    canonicalizeTags <span class="op">.</span></span>
+<span id="cb118-9"><a href="#cb118-9" aria-hidden="true"></a>    parseTags</span></code></pre></div>
+</div>
+<div id="the-either-type" class="slide section level1">
+<h1>The <code>Either</code> type</h1>
+<p>The <code>Either</code> type represents values with two possibilities:</p>
+<pre><code>data Either a b 
+  = Left a 
+  | Right b</code></pre>
+<p>Simply put, a value of type Either a b can contain either a value of type a, or a value of type b.</p>
+<pre><code>Left True :: Either Bool b
+Right &#39;a&#39; :: Either a Char</code></pre>
+<p>With this type, we can use the <code>Left</code> constructor to indicate failure with some error value attached, and the <code>Right</code> constructor with one type to represent success with the expected result.</p>
+</div>
+<div id="error-handling-fmap-on-either" class="slide section level1">
+<h1>Error handling: fmap on <code>Either</code></h1>
+<ul>
+<li>By convention, fmap will ignore Left values, but will apply the supplied function to values contained in a Right:</li>
+</ul>
+<pre><code>instance Functor (Either a) where
+    fmap _ (Left x) = Left x
+    fmap f (Right y) = Right (f y)</code></pre>
+<p>Mnemonic: <code>Left</code> is wrong and <code>Right</code> is right, right?</p>
+<p>This enables us to write code without bothering about previous errors. More on error handling can be found <a href="https://learn-haskell.blog/06-errors_and_files/01-either.html">here</a>.</p>
+</div>
+<div id="a-brief-note-on-catching-exceptions" class="slide section level1">
+<h1>A brief note on catching exceptions</h1>
+<ul>
+<li>Haskell exception system is modeled off of Java-style Object Oriented inheritance (shocking, isn’t it?)</li>
+<li>There’s a typeclass, <a href="https://hackage.haskell.org/package/base-4.19.1.0/docs/Control-Exception.html">Exception</a>, and a data type <code>SomeException</code> which is the ancestor of all exceptions.</li>
+</ul>
+<pre><code>data MyException = ThisException | ThatException
+    deriving Show
+
+instance Exception MyException</code></pre>
+<p>These Exceptions are commonly used as type for the <code>Left</code> case.</p>
 </div>
 <div id="from-links-to-spidering" class="slide section level1">
 <h1>From links to spidering</h1>
@@ -1346,20 +1404,20 @@ <h1>What we need to track</h1>
 <h1>Tracking what we’ve seen</h1>
 <p>For any given page, we need to remember both it and all the pages it links to.</p>
 <p>One possibility for associating the two is a <em>tuple</em>:</p>
-<div class="sourceCode" id="cb119"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb119-1"><a href="#cb119-1" aria-hidden="true"></a>(<span class="st">&quot;http://x.org/&quot;</span>, [<span class="st">&quot;http://microsoft.com/&quot;</span>])</span></code></pre></div>
+<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb123-1"><a href="#cb123-1" aria-hidden="true"></a>(<span class="st">&quot;http://x.org/&quot;</span>, [<span class="st">&quot;http://microsoft.com/&quot;</span>])</span></code></pre></div>
 <p>Tuples are useful any time we want mixed-type data without the hassle of creating a new type.</p>
 <p>Speaking of a new type, here’s how we’d define one:</p>
-<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb120-1"><a href="#cb120-1" aria-hidden="true"></a><span class="kw">data</span> <span class="dt">Link</span> <span class="ot">=</span> <span class="dt">Link</span> <span class="dt">String</span> [<span class="dt">String</span>]</span>
-<span id="cb120-2"><a href="#cb120-2" aria-hidden="true"></a></span>
-<span id="cb120-3"><a href="#cb120-3" aria-hidden="true"></a><span class="co">-- Let&#39;s define some accessors, too.</span></span>
-<span id="cb120-4"><a href="#cb120-4" aria-hidden="true"></a>linkFrom (<span class="dt">Link</span> url _) <span class="ot">=</span> url</span>
-<span id="cb120-5"><a href="#cb120-5" aria-hidden="true"></a>linkTo (<span class="dt">Link</span> _ links) <span class="ot">=</span> links</span></code></pre></div>
+<div class="sourceCode" id="cb124"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true"></a><span class="kw">data</span> <span class="dt">Link</span> <span class="ot">=</span> <span class="dt">Link</span> <span class="dt">String</span> [<span class="dt">String</span>]</span>
+<span id="cb124-2"><a href="#cb124-2" aria-hidden="true"></a></span>
+<span id="cb124-3"><a href="#cb124-3" aria-hidden="true"></a><span class="co">-- Let&#39;s define some accessors, too.</span></span>
+<span id="cb124-4"><a href="#cb124-4" aria-hidden="true"></a>linkFrom (<span class="dt">Link</span> url _) <span class="ot">=</span> url</span>
+<span id="cb124-5"><a href="#cb124-5" aria-hidden="true"></a>linkTo (<span class="dt">Link</span> _ links) <span class="ot">=</span> links</span></code></pre></div>
 </div>
 <div id="avoiding-duplication" class="slide section level1">
 <h1>Avoiding duplication</h1>
 <p>We don’t want to visit any URL twice.</p>
 <p>How do we avoid this?</p>
-<div class="sourceCode" id="cb121"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb121-1"><a href="#cb121-1" aria-hidden="true"></a>visited url <span class="ot">=</span> <span class="fu">elem</span> url <span class="op">.</span> <span class="fu">map</span> linkTo</span></code></pre></div>
+<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb125-1"><a href="#cb125-1" aria-hidden="true"></a>visited url <span class="ot">=</span> <span class="fu">elem</span> url <span class="op">.</span> <span class="fu">map</span> linkTo</span></code></pre></div>
 <p>This function has a problem - what is that problem?</p>
 </div>
 <div id="better-performance" class="slide section level1">
@@ -1373,9 +1431,9 @@ <h1>Maps and importing</h1>
 <p>Instead, we use <em>immutable</em> key-value maps.</p>
 <p>We must perform fancy module importing tricks because the <code>Data.Map</code> module defines a lot of names that would otherwise overlap with built-in names.</p>
 <p>This means “only import the name <code>Map</code> from <code>Data.Map</code>”:</p>
-<div class="sourceCode" id="cb122"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb122-1"><a href="#cb122-1" aria-hidden="true"></a><span class="kw">import</span> <span class="dt">Data.Map</span> (<span class="dt">Map</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true"></a><span class="kw">import</span> <span class="dt">Data.Map</span> (<span class="dt">Map</span>)</span></code></pre></div>
 <p>And this means “import everything from <code>Data.Map</code>, but all those names must be prefixed with <code>Map.</code>”:</p>
-<div class="sourceCode" id="cb123"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb123-1"><a href="#cb123-1" aria-hidden="true"></a><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></span></code></pre></div>
+<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb127-1"><a href="#cb127-1" aria-hidden="true"></a><span class="kw">import</span> <span class="kw">qualified</span> <span class="dt">Data.Map</span> <span class="kw">as</span> <span class="dt">Map</span></span></code></pre></div>
 </div>
 <div id="what-use-is-an-immutable-data-structure" class="slide section level1">
 <h1>What use is an immutable data structure?</h1>
@@ -1390,27 +1448,43 @@ <h1>What use is an immutable data structure?</h1>
 <div id="a-fistful-of-dollars" class="slide section level1">
 <h1>A fistful of dollars</h1>
 <p>Here’s a surprisingly handy built-in operator:</p>
-<div class="sourceCode" id="cb124"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true"></a>f <span class="op">$</span> x <span class="ot">=</span> f x</span></code></pre></div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true"></a>f <span class="op">$</span> x <span class="ot">=</span> f x</span></code></pre></div>
 <p>Why is this useful? Because it lets us eliminate parentheses.</p>
 <p>Before:</p>
-<div class="sourceCode" id="cb125"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb125-1"><a href="#cb125-1" aria-hidden="true"></a>explode k <span class="ot">=</span> <span class="fu">error</span> (<span class="st">&quot;failed on &quot;</span> <span class="op">++</span> <span class="fu">show</span> k)</span></code></pre></div>
+<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb129-1"><a href="#cb129-1" aria-hidden="true"></a>explode k <span class="ot">=</span> <span class="fu">error</span> (<span class="st">&quot;failed on &quot;</span> <span class="op">++</span> <span class="fu">show</span> k)</span></code></pre></div>
 <p>After:</p>
-<div class="sourceCode" id="cb126"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true"></a>explode k <span class="ot">=</span> <span class="fu">error</span> <span class="op">$</span> <span class="st">&quot;failed on &quot;</span> <span class="op">++</span> <span class="fu">show</span> k</span></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true"></a>explode k <span class="ot">=</span> <span class="fu">error</span> <span class="op">$</span> <span class="st">&quot;failed on &quot;</span> <span class="op">++</span> <span class="fu">show</span> k</span></code></pre></div>
 </div>
 <div id="partial-application" class="slide section level1">
 <h1>Partial application</h1>
 <p>This is annoying to write:</p>
-<div class="sourceCode" id="cb127"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb127-1"><a href="#cb127-1" aria-hidden="true"></a>increment k <span class="ot">=</span> <span class="dv">1</span> <span class="op">+</span> k</span></code></pre></div>
+<div class="sourceCode" id="cb131"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb131-1"><a href="#cb131-1" aria-hidden="true"></a>increment k <span class="ot">=</span> <span class="dv">1</span> <span class="op">+</span> k</span></code></pre></div>
 <p>Almost as bad:</p>
-<div class="sourceCode" id="cb128"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true"></a>\k <span class="ot">-&gt;</span> <span class="dv">1</span> <span class="op">+</span> k</span></code></pre></div>
+<div class="sourceCode" id="cb132"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb132-1"><a href="#cb132-1" aria-hidden="true"></a>\k <span class="ot">-&gt;</span> <span class="dv">1</span> <span class="op">+</span> k</span></code></pre></div>
 <p>Much handier, and identical:</p>
-<div class="sourceCode" id="cb129"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb129-1"><a href="#cb129-1" aria-hidden="true"></a>(<span class="dv">1</span><span class="op">+</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb133"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb133-1"><a href="#cb133-1" aria-hidden="true"></a>(<span class="dv">1</span><span class="op">+</span>)</span></code></pre></div>
 <p>In fact, this is valid:</p>
-<div class="sourceCode" id="cb130"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true"></a>increment <span class="ot">=</span> (<span class="dv">1</span><span class="op">+</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb134"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb134-1"><a href="#cb134-1" aria-hidden="true"></a>increment <span class="ot">=</span> (<span class="dv">1</span><span class="op">+</span>)</span></code></pre></div>
 </div>
 <div id="spidering-in-all-its-glory" class="slide section level1">
 <h1>Spidering, in all its glory</h1>
-<p>~~~~ {.haskell} spider :: Int -&gt; String -&gt; IO (Map.Map String [String]) spider count url0 = go 0 Map.empty (Set.singleton url0) where go k seen queue0 | k &gt;= count = return seen | otherwise = case Set.minView queue0 of Nothing -&gt; return seen Just (url, queue) -&gt; do request &lt;- parseRequest url page &lt;- download request let ls = links url page newSeen = Map.insert url ls seen notSeen = Set.fromList . filter (<code>Map.notMember</code> newSeen) $ ls newQueue = queue <code>Set.union</code> notSeen go (k+1) newSeen newQueue~~~~</p>
+<div class="sourceCode" id="cb135"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true"></a><span class="ot">spider ::</span> <span class="dt">Int</span> <span class="ot">-&gt;</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">IO</span> (<span class="dt">Map.Map</span> <span class="dt">String</span> [<span class="dt">String</span>])</span>
+<span id="cb135-2"><a href="#cb135-2" aria-hidden="true"></a>spider count url0 <span class="ot">=</span> go <span class="dv">0</span> Map.empty (Set.singleton url0)</span>
+<span id="cb135-3"><a href="#cb135-3" aria-hidden="true"></a>  <span class="kw">where</span></span>
+<span id="cb135-4"><a href="#cb135-4" aria-hidden="true"></a>    go k seen queue0</span>
+<span id="cb135-5"><a href="#cb135-5" aria-hidden="true"></a>        <span class="op">|</span> k <span class="op">&gt;=</span> count <span class="ot">=</span> <span class="fu">return</span> seen</span>
+<span id="cb135-6"><a href="#cb135-6" aria-hidden="true"></a>        <span class="op">|</span> <span class="fu">otherwise</span>  <span class="ot">=</span></span>
+<span id="cb135-7"><a href="#cb135-7" aria-hidden="true"></a>      <span class="kw">case</span> Set.minView queue0 <span class="kw">of</span></span>
+<span id="cb135-8"><a href="#cb135-8" aria-hidden="true"></a>        <span class="dt">Nothing</span> <span class="ot">-&gt;</span> <span class="fu">return</span> seen</span>
+<span id="cb135-9"><a href="#cb135-9" aria-hidden="true"></a>        <span class="dt">Just</span> (url, queue) <span class="ot">-&gt;</span> <span class="kw">do</span></span>
+<span id="cb135-10"><a href="#cb135-10" aria-hidden="true"></a>          request <span class="ot">&lt;-</span> parseRequest  url</span>
+<span id="cb135-11"><a href="#cb135-11" aria-hidden="true"></a>          page <span class="ot">&lt;-</span> download request</span>
+<span id="cb135-12"><a href="#cb135-12" aria-hidden="true"></a>          <span class="kw">let</span> ls       <span class="ot">=</span> links url page</span>
+<span id="cb135-13"><a href="#cb135-13" aria-hidden="true"></a>              newSeen  <span class="ot">=</span> Map.insert url ls seen</span>
+<span id="cb135-14"><a href="#cb135-14" aria-hidden="true"></a>              notSeen  <span class="ot">=</span> Set.fromList <span class="op">.</span></span>
+<span id="cb135-15"><a href="#cb135-15" aria-hidden="true"></a>                         <span class="fu">filter</span> (<span class="ot">`Map.notMember`</span> newSeen) <span class="op">$</span> ls</span>
+<span id="cb135-16"><a href="#cb135-16" aria-hidden="true"></a>              newQueue <span class="ot">=</span> queue <span class="ot">`Set.union`</span> notSeen</span>
+<span id="cb135-17"><a href="#cb135-17" aria-hidden="true"></a>          go (k<span class="op">+</span><span class="dv">1</span>) newSeen newQueue</span></code></pre></div>
 </div>
 <div id="where-do-we-stand" class="slide section level1">
 <h1>Where do we stand?</h1>
diff --git a/slides/slidesEnglish.md b/slides/slidesEnglish.md
index 7503ec6..b60ff9d 100644
--- a/slides/slidesEnglish.md
+++ b/slides/slidesEnglish.md
@@ -1893,7 +1893,8 @@ Hoover over the blue line, select the blue dot and `apply hint "use mapMaybe"`
 ~~~~{.haskell}
 links :: String -> String -> [String]
 links url =
-    mapMaybe (canonicalizeLink url) . filter (not . null) .
+    mapMaybe (canonicalizeLink url) . 
+    filter (not . null) .
     map (fromAttrib "href") .
     filter (not . nofollow) .
     filter (isTagOpenName "a") .
@@ -1901,6 +1902,52 @@ links url =
     parseTags
 ~~~~
 
+# The `Either` type
+
+The `Either` type represents values with two possibilities:
+
+~~~
+data Either a b 
+  = Left a 
+  | Right b
+~~~
+
+Simply put, a value of type Either a b can contain either a value of type a, or a value of type b.
+
+~~~
+Left True :: Either Bool b
+Right 'a' :: Either a Char
+~~~
+
+With this type, we can use the `Left` constructor to indicate failure with some error value attached, and the `Right` constructor with one type to represent success with the expected result.
+
+# Error handling: fmap on `Either`
+
+* By convention, fmap will ignore Left values, but will apply the supplied function to values contained in a Right:
+~~~
+instance Functor (Either a) where
+    fmap _ (Left x) = Left x
+    fmap f (Right y) = Right (f y)
+~~~
+
+Mnemonic: `Left` is wrong and `Right` is right, right?
+
+This enables us to write code without bothering about previous errors. More on error handling can be found [here](https://learn-haskell.blog/06-errors_and_files/01-either.html).
+
+
+# A brief note on catching exceptions
+
+* Haskell exception system is modeled off of Java-style Object Oriented inheritance (shocking, isn't it?)
+* There’s a typeclass, [Exception](https://hackage.haskell.org/package/base-4.19.1.0/docs/Control-Exception.html), and a data type `SomeException` which is the ancestor of all exceptions.
+
+~~~
+data MyException = ThisException | ThatException
+    deriving Show
+
+instance Exception MyException
+~~~
+
+These Exceptions are commonly used as type for the `Left` case. 
 
 # From links to spidering