fix: generate.sh

pierluc-codes · pierluc-codes · commit 9fca6e845aff · 2025-11-20T20:28:58.000-05:00
diff --git a/markdown/config/pandoc-defaults.yml b/markdown/config/pandoc-defaults.yml
@@ -1,4 +1,3 @@
 from: markdown-implicit_figures
 to: html
-highlight-style: null
 standalone: true
diff --git a/markdown/config/template.html b/markdown/config/template.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
    "https://www.w3.org/TR/html4/strict.dtd">
-<html lange="en">
+<html lang="en">
 <head>
 <title>$title$ - Learn You a Haskell for Great Good!</title>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
diff --git a/markdown/generate.sh b/markdown/generate.sh
@@ -1,4 +1,5 @@
-#!/bin/bash
+#!/usr/bin/env bash
+set -e
 
 mapfile -t filename <config/file-list.txt
 
diff --git a/markdown/generated_html/functors-applicative-functors-and-monoids.html b/markdown/generated_html/functors-applicative-functors-and-monoids.html
@@ -413,7 +413,7 @@ <h2 id="functors-redux">Functors redux</h2>
     fmap f (Just x) = Just (f x)
     fmap f Nothing = Nothing</code></pre>
 <p>We imagine that <code>id</code> plays the role of the <code>f</code>
-parameter in the implementation. We see that if wee <code>fmap id</code>
+parameter in the implementation. We see that if we <code>fmap id</code>
 over <code>Just x</code>, the result will be <code>Just (id x)</code>,
 and because <code>id</code> just returns its parameter, we can deduce
 that <code>Just (id x)</code> equals <code>Just x</code>. So now we know
diff --git a/markdown/generated_html/higher-order-functions.html b/markdown/generated_html/higher-order-functions.html
@@ -156,12 +156,10 @@ <h2 id="curried-functions">Curried functions</h2>
 instead of binding it to a name with a <em>let</em> or passing it to
 another function?</p>
 <pre class="haskell:hs"><code>ghci&gt; multThree 3 4
-&lt;interactive&gt;:1:0:
-    No instance for (Show (t -&gt; t))
-      arising from a use of `print&#39; at &lt;interactive&gt;:1:0-12
-    Possible fix: add an instance declaration for (Show (t -&gt; t))
-    In the expression: print it
-    In a &#39;do&#39; expression: print it</code></pre>
+&lt;interactive&gt;:1:1: error: [GHC-39999]
+    • No instance for ‘Show (a0 -&gt; a0)’ arising from a use of ‘print’
+        (maybe you haven&#39;t applied a function to enough arguments?)
+    • In a stmt of an interactive GHCi command: print it</code></pre>
 <p>GHCI is telling us that the expression produced a function of type
 <code>a -&gt; a</code> but it doesn’t know how to print it to the
 screen. Functions aren’t instances of the <code>Show</code> typeclass,
diff --git a/markdown/generated_html/introduction.html b/markdown/generated_html/introduction.html
@@ -57,7 +57,9 @@ <h2 id="about-this-tutorial">About this tutorial</h2>
 Haskell.</p>
 <p>The channel #haskell on the Libera.Chat network is a great place to
 ask questions if you’re feeling stuck. People there are extremely nice,
-patient and understanding to newbies.</p>
+patient and understanding to newbies. If IRC it not your cup of tea, <a
+href="https://discourse.haskell.org">https://discourse.haskell.org</a>
+is a popular community forum with a section for learners.</p>
 <p>I failed to learn Haskell approximately 2 times before finally
 grasping it because it all just seemed too weird to me and I didn’t get
 it. But then once it just “clicked” and after getting over that initial
diff --git a/markdown/generated_html/making-our-own-types-and-typeclasses.html b/markdown/generated_html/making-our-own-types-and-typeclasses.html
@@ -1013,8 +1013,8 @@ <h2 id="recursive-data-structures">Recursive data structures</h2>
 ghci&gt; let b = 6 :-: 7 :-: Empty
 ghci&gt; a .++ b
 (:-:) 3 ((:-:) 4 ((:-:) 5 ((:-:) 6 ((:-:) 7 Empty))))</code></pre>
-<p>Nice. Is nice. If we wanted, we could implement all of the functions
-that operate on lists on our own list type.</p>
+<p>Nice. If we wanted, we could implement all of the functions that
+operate on lists on our own list type.</p>
 <p>Notice how we pattern matched on <code>(x :-: xs)</code>. That works
 because pattern matching is actually about matching constructors. We can
 match on <code>:-:</code> because it is a constructor for our own list
diff --git a/markdown/generated_html/starting-out.html b/markdown/generated_html/starting-out.html
@@ -97,8 +97,10 @@ <h2 id="ready-set-go">Ready, set, go!</h2>
 True</code></pre>
 <p>What about doing <code>5 + "llama"</code> or <code>5 == True</code>?
 Well, if we try the first snippet, we get a big scary error message!</p>
-<pre class="haskell: ghci"><code>• No instance for (Num String) arising from a use of ‘+’
-    • In the expression: 5 + &quot;llama&quot;
+<pre class="haskell: ghci"><code>&lt;interactive&gt;:1:1: error: [GHC-39999]
+    • No instance for ‘Num String’ arising from the literal ‘5’
+    • In the first argument of ‘(+)’, namely ‘5’
+      In the expression: 5 + &quot;llama&quot;
       In an equation for ‘it’: it = 5 + &quot;llama&quot;</code></pre>
 <p>Yikes! What GHCI is telling us here is that <code>"llama"</code> is
 not a number and so it doesn’t know how to add it to 5. Even if it
@@ -114,6 +116,13 @@ <h2 id="ready-set-go">Ready, set, go!</h2>
 sneaky and can act like an integer or a floating-point number.
 <code>4.0</code> can’t act like an integer, so <code>5</code> is the one
 that has to adapt.</p>
+<div class="hintbox">
+<p><strong>Note:</strong> GHC errors are all assigned unique identifiers
+such as <code>GHC-39999</code> above. Whenever you are stuck with a
+stubborn error, you can look it up at <a
+href="https://errors.haskell.org/">https://errors.haskell.org/</a> to
+learn typical causes and solutions.</p>
+</div>
 <p>You may not have known it but we’ve been using functions now all
 along. For instance, <code>*</code> is a function that takes two numbers
 and multiplies them. As you’ve seen, we call it by sandwiching it
@@ -179,7 +188,8 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 <p>In the previous section we got a basic feel for calling functions.
 Now let’s try making our own! Open up your favorite text editor and
 punch in this function that takes a number and multiplies it by two.</p>
-<pre class="haskell: hs"><code>doubleMe x = x + x</code></pre>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>doubleMe x <span class="ot">=</span> x <span class="op">+</span> x</span></code></pre></div>
 <p>Functions are defined in a similar way that they are called. The
 function name is followed by parameters separated by spaces. But when
 defining functions, there’s a <code>=</code> and after that we define
@@ -198,7 +208,8 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 numbers (anything that can be considered a number, really), our function
 also works on any number. Let’s make a function that takes two numbers
 and multiplies each by two and then adds them together.</p>
-<pre class="haskell: hs"><code>doubleUs x y = x*2 + y*2</code></pre>
+<div class="sourceCode" id="cb12"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a>doubleUs x y <span class="ot">=</span> x<span class="op">*</span><span class="dv">2</span> <span class="op">+</span> y<span class="op">*</span><span class="dv">2</span></span></code></pre></div>
 <p>Simple. We could have also defined it as
 <code>doubleUs x y = x + x + y + y</code>. Testing it out produces
 pretty predictable results (remember to append this function to the
@@ -213,7 +224,8 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 <p>As expected, you can call your own functions from other functions
 that you made. With that in mind, we could redefine
 <code>doubleUs</code> like this:</p>
-<pre class="haskell: hs"><code>doubleUs x y = doubleMe x + doubleMe y</code></pre>
+<div class="sourceCode" id="cb14"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a>doubleUs x y <span class="ot">=</span> doubleMe x <span class="op">+</span> doubleMe y</span></code></pre></div>
 <p>This is a very simple example of a common pattern you will see
 throughout Haskell. Making basic functions that are obviously correct
 and then combining them into more complex functions. This way you also
@@ -228,9 +240,10 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 <p>Now we’re going to make a function that multiplies a number by 2 but
 only if that number is smaller than or equal to 100 because numbers
 bigger than 100 are big enough as it is!</p>
-<pre class="haskell: hs"><code>doubleSmallNumber x = if x &gt; 100
-                        then x
-                        else x*2</code></pre>
+<div class="sourceCode" id="cb15"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a>doubleSmallNumber x <span class="ot">=</span> <span class="kw">if</span> x <span class="op">&gt;</span> <span class="dv">100</span></span>
+<span id="cb15-2"><a href="#cb15-2" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">then</span> x</span>
+<span id="cb15-3"><a href="#cb15-3" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">else</span> x<span class="op">*</span><span class="dv">2</span></span></code></pre></div>
 <p><img src="assets/images/starting-out/baby.png" class="left"
 width="140" height="211" alt="this is you" /></p>
 <p>Right here we introduced Haskell’s if statement. You’re probably
@@ -249,7 +262,8 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 that’s why it’s an expression. If we wanted to add one to every number
 that’s produced in our previous function, we could have written its body
 like this.</p>
-<pre class="haskell: hs"><code>doubleSmallNumber&#39; x = (if x &gt; 100 then x else x*2) + 1</code></pre>
+<div class="sourceCode" id="cb16"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a>doubleSmallNumber&#39; x <span class="ot">=</span> (<span class="kw">if</span> x <span class="op">&gt;</span> <span class="dv">100</span> <span class="kw">then</span> x <span class="kw">else</span> x<span class="op">*</span><span class="dv">2</span>) <span class="op">+</span> <span class="dv">1</span></span></code></pre></div>
 <p>Had we omitted the parentheses, it would have added one only if
 <code>x</code> wasn’t greater than 100. Note the <code>'</code> at the
 end of the function name. That apostrophe doesn’t have any special
@@ -258,7 +272,8 @@ <h2 id="babys-first-functions">Baby’s first functions</h2>
 a function (one that isn’t lazy) or a slightly modified version of a
 function or a variable. Because <code>'</code> is a valid character in
 functions, we can make a function like this.</p>
-<pre class="haskell: hs"><code>conanO&#39;Brien = &quot;It&#39;s a-me, Conan O&#39;Brien!&quot;</code></pre>
+<div class="sourceCode" id="cb17"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a>conanO&#39;Brien <span class="ot">=</span> <span class="st">&quot;It&#39;s a-me, Conan O&#39;Brien!&quot;</span></span></code></pre></div>
 <p>There are two noteworthy things here. The first is that in the
 function name we didn’t capitalize Conan’s name. That’s because
 functions can’t begin with uppercase letters. We’ll see why a bit later.
@@ -512,7 +527,7 @@ <h2 id="texas-ranges">Texas ranges</h2>
 you could do <code>[13,26..24*13]</code>. But there’s a better way:
 <code>take 24 [13,26..]</code>. Because Haskell is lazy, it won’t try to
 evaluate the infinite list immediately because it would never finish.
-It’ll wait to see what you want to get out of that infinite lists. And
+It’ll wait to see what you want to get out of that infinite list. And
 here it sees you just want the first 24 elements and it gladly
 obliges.</p>
 <p>A handful of functions that produce infinite lists:</p>
@@ -579,8 +594,9 @@ <h2 id="im-a-list-comprehension">I’m a list comprehension</h2>
 <code>odd</code> returns <code>True</code> on an odd number and
 <code>False</code> on an even one. The element is included in the list
 only if all the predicates evaluate to <code>True</code>.</p>
-<pre class="haskell: hs"><code>ghci&gt; boomBangs [7..13]
-[&quot;BOOM!&quot;,&quot;BOOM!&quot;,&quot;BANG!&quot;,&quot;BANG!&quot;]</code></pre>
+<div class="sourceCode" id="cb46"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb46-1"><a href="#cb46-1" aria-hidden="true" tabindex="-1"></a>ghci<span class="op">&gt;</span> boomBangs [<span class="dv">7</span><span class="op">..</span><span class="dv">13</span>]</span>
+<span id="cb46-2"><a href="#cb46-2" aria-hidden="true" tabindex="-1"></a>[<span class="st">&quot;BOOM!&quot;</span>,<span class="st">&quot;BOOM!&quot;</span>,<span class="st">&quot;BANG!&quot;</span>,<span class="st">&quot;BANG!&quot;</span>]</span></code></pre></div>
 <p>We can include several predicates. If we wanted all numbers from 10
 to 20 that are not 13, 15 or 19, we’d do:</p>
 <pre class="haskell: ghci"><code>ghci&gt; [ x | x &lt;- [10..20], x /= 13, x /= 15, x /= 19]
@@ -610,7 +626,8 @@ <h2 id="im-a-list-comprehension">I’m a list comprehension</h2>
 &quot;grouchy pope&quot;,&quot;scheming hobo&quot;,&quot;scheming frog&quot;,&quot;scheming pope&quot;]</code></pre>
 <p>I know! Let’s write our own version of <code>length</code>! We’ll
 call it <code>length'</code>.</p>
-<pre class="haskell: hs"><code>length&#39; xs = sum [1 | _ &lt;- xs]</code></pre>
+<div class="sourceCode" id="cb51"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb51-1"><a href="#cb51-1" aria-hidden="true" tabindex="-1"></a>length&#39; xs <span class="ot">=</span> <span class="fu">sum</span> [<span class="dv">1</span> <span class="op">|</span> _ <span class="ot">&lt;-</span> xs]</span></code></pre></div>
 <p><code>_</code> means that we don’t care what we’ll draw from the list
 anyway so instead of writing a variable name that we’ll never use, we
 just write <code>_</code>. This function replaces every element of a
@@ -620,7 +637,8 @@ <h2 id="im-a-list-comprehension">I’m a list comprehension</h2>
 comprehensions to process and produce strings. Here’s a function that
 takes a string and removes everything except uppercase letters from
 it.</p>
-<pre class="haskell: hs"><code>removeNonUppercase st = [ c | c &lt;- st, c `elem` [&#39;A&#39;..&#39;Z&#39;]]</code></pre>
+<div class="sourceCode" id="cb52"><pre
+class="sourceCode haskell: hs"><code class="sourceCode haskell"><span id="cb52-1"><a href="#cb52-1" aria-hidden="true" tabindex="-1"></a>removeNonUppercase st <span class="ot">=</span> [ c <span class="op">|</span> c <span class="ot">&lt;-</span> st, c <span class="ot">`elem`</span> [<span class="ch">&#39;A&#39;</span><span class="op">..</span><span class="ch">&#39;Z&#39;</span>]]</span></code></pre></div>
 <p>Testing it out:</p>
 <pre class="haskell: ghci"><code>ghci&gt; removeNonUppercase &quot;Hahaha! Ahahaha!&quot;
 &quot;HA&quot;
@@ -665,8 +683,9 @@ <h2 id="tuples">Tuples</h2>
 brackets, we use parentheses: <code>[(1,2),(8,11),(4,5)]</code>. What if
 we tried to make a shape like <code>[(1,2),(8,11,5),(4,5)]</code>? Well,
 we’d get this error:</p>
-<pre class="haskell: ghci"><code>• Couldn&#39;t match expected type ‘(a, b)’
-                  with actual type ‘(a0, b0, c0)’
+<pre class="haskell: ghci"><code>&lt;interactive&gt;:1:8: error: [GHC-83865]
+    • Couldn&#39;t match expected type: (a, b)
+                  with actual type: (a0, b0, c0)
     • In the expression: (8, 11, 5)
       In the expression: [(1, 2), (8, 11, 5), (4, 5)]
       In an equation for ‘it’: it = [(1, 2), (8, 11, 5), (4, 5)]
diff --git a/markdown/generated_html/syntax-in-functions.html b/markdown/generated_html/syntax-in-functions.html
diff --git a/markdown/generated_html/types-and-typeclasses.html b/markdown/generated_html/types-and-typeclasses.html
