From ced47da8c776b3d2a682f00bf4b583a9556dafbf Mon Sep 17 00:00:00 2001
From: Nadia Polikarpova <nadia.polikarpova@gmail.com>
Date: Fri, 24 May 2024 11:32:20 -0700
Subject: [PATCH] update page

---
 docs/lectures/07-classes.html |  308 ++-----
 lectures/07-classes.md        |  363 ++------
 lectures/info_ocaml.md        |   67 --
 lectures/info_prolog.md       |   50 --
 lectures/partial-solutions.md |  218 -----
 lectures/piazza.md            |   17 -
 lectures/prolog.md            | 1562 ---------------------------------
 7 files changed, 136 insertions(+), 2449 deletions(-)
 delete mode 100644 lectures/info_ocaml.md
 delete mode 100644 lectures/info_prolog.md
 delete mode 100644 lectures/partial-solutions.md
 delete mode 100644 lectures/piazza.md
 delete mode 100644 lectures/prolog.md

diff --git a/docs/lectures/07-classes.html b/docs/lectures/07-classes.html
index d80b904..682bab9 100644
--- a/docs/lectures/07-classes.html
+++ b/docs/lectures/07-classes.html
@@ -945,7 +945,7 @@ <h2 id="constraint-propagation">Constraint Propagation</h2>
 <br>
 <br>
 <br></p>
-<h2 id="try-at-home-a-faster-dictionary">TRY AT HOME: A Faster Dictionary</h2>
+<h2 id="exercise-a-faster-dictionary">EXERCISE: A Faster Dictionary</h2>
 <p>Write an optimized version of</p>
 <ul>
 <li><code class="sourceCode haskell">add</code> that ensures the keys are in <em>increasing</em> order</li>
@@ -1062,262 +1062,93 @@ <h2 id="creating-typeclasses">Creating Typeclasses</h2>
 <br>
 <br>
 <br></p>
-<h2 id="json">JSON</h2>
-<p><em>JavaScript Object Notation</em> or <a href="http://www.json.org/">JSON</a> is a simple format for
-transferring data around. Here is an example:</p>
-<div class="sourceCode" id="cb35"><pre class="sourceCode json"><code class="sourceCode json"><span id="cb35-1"><a href="#cb35-1" aria-hidden="true" tabindex="-1"></a><span class="fu">{</span> <span class="dt">&quot;name&quot;</span>    <span class="fu">:</span> <span class="st">&quot;Nadia&quot;</span></span>
-<span id="cb35-2"><a href="#cb35-2" aria-hidden="true" tabindex="-1"></a><span class="fu">,</span> <span class="dt">&quot;age&quot;</span>     <span class="fu">:</span> <span class="fl">39.0</span></span>
-<span id="cb35-3"><a href="#cb35-3" aria-hidden="true" tabindex="-1"></a><span class="fu">,</span> <span class="dt">&quot;likes&quot;</span>   <span class="fu">:</span> <span class="ot">[</span> <span class="st">&quot;poke&quot;</span><span class="ot">,</span> <span class="st">&quot;tea&quot;</span><span class="ot">,</span> <span class="st">&quot;pasta&quot;</span> <span class="ot">]</span></span>
-<span id="cb35-4"><a href="#cb35-4" aria-hidden="true" tabindex="-1"></a><span class="fu">,</span> <span class="dt">&quot;hates&quot;</span>   <span class="fu">:</span> <span class="ot">[</span> <span class="st">&quot;beets&quot;</span> <span class="ot">,</span> <span class="st">&quot;milk&quot;</span> <span class="ot">]</span></span>
-<span id="cb35-5"><a href="#cb35-5" aria-hidden="true" tabindex="-1"></a><span class="fu">,</span> <span class="dt">&quot;lunches&quot;</span> <span class="fu">:</span> <span class="ot">[</span> <span class="fu">{</span><span class="dt">&quot;day&quot;</span> <span class="fu">:</span> <span class="st">&quot;mon&quot;</span><span class="fu">,</span> <span class="dt">&quot;loc&quot;</span> <span class="fu">:</span> <span class="st">&quot;fan fan&quot;</span><span class="fu">}</span></span>
-<span id="cb35-6"><a href="#cb35-6" aria-hidden="true" tabindex="-1"></a>              <span class="ot">,</span> <span class="fu">{</span><span class="dt">&quot;day&quot;</span> <span class="fu">:</span> <span class="st">&quot;tue&quot;</span><span class="fu">,</span> <span class="dt">&quot;loc&quot;</span> <span class="fu">:</span> <span class="st">&quot;home&quot;</span><span class="fu">}</span></span>
-<span id="cb35-7"><a href="#cb35-7" aria-hidden="true" tabindex="-1"></a>              <span class="ot">,</span> <span class="fu">{</span><span class="dt">&quot;day&quot;</span> <span class="fu">:</span> <span class="st">&quot;wed&quot;</span><span class="fu">,</span> <span class="dt">&quot;loc&quot;</span> <span class="fu">:</span> <span class="st">&quot;curry up now&quot;</span><span class="fu">}</span></span>
-<span id="cb35-8"><a href="#cb35-8" aria-hidden="true" tabindex="-1"></a>              <span class="ot">,</span> <span class="fu">{</span><span class="dt">&quot;day&quot;</span> <span class="fu">:</span> <span class="st">&quot;thu&quot;</span><span class="fu">,</span> <span class="dt">&quot;loc&quot;</span> <span class="fu">:</span> <span class="st">&quot;home&quot;</span><span class="fu">}</span></span>
-<span id="cb35-9"><a href="#cb35-9" aria-hidden="true" tabindex="-1"></a>              <span class="ot">,</span> <span class="fu">{</span><span class="dt">&quot;day&quot;</span> <span class="fu">:</span> <span class="st">&quot;fri&quot;</span><span class="fu">,</span> <span class="dt">&quot;loc&quot;</span> <span class="fu">:</span> <span class="st">&quot;rubios&quot;</span><span class="fu">}</span> <span class="ot">]</span></span>
-<span id="cb35-10"><a href="#cb35-10" aria-hidden="true" tabindex="-1"></a><span class="fu">}</span></span></code></pre></div>
-<p>Each JSON value is either</p>
-<ul>
-<li><p>a <em>base</em> value like a string, a number or a boolean,</p></li>
-<li><p>an (ordered) <em>array</em> of values, or</p></li>
-<li><p>an <em>object</em>, i.e. a set of <em>string-value</em> pairs.</p></li>
-</ul>
+<h2 id="dictionary-with-default-values">Dictionary with Default Values</h2>
+<p>Recall that our <code class="sourceCode haskell">get</code> function throws an error when the key is not found:</p>
+<div class="sourceCode" id="cb35"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb35-1"><a href="#cb35-1" aria-hidden="true" tabindex="-1"></a>get key <span class="dt">Empty</span>      <span class="ot">=</span> <span class="fu">error</span> <span class="st">&quot;key not found&quot;</span></span>
+<span id="cb35-2"><a href="#cb35-2" aria-hidden="true" tabindex="-1"></a>get key (<span class="dt">Bind</span> oldK v rest)</span>
+<span id="cb35-3"><a href="#cb35-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">==</span> oldK    <span class="ot">=</span> v</span>
+<span id="cb35-4"><a href="#cb35-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">&lt;</span> oldK     <span class="ot">=</span> <span class="fu">error</span> <span class="st">&quot;key not found&quot;</span></span>
+<span id="cb35-5"><a href="#cb35-5" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="fu">otherwise</span>      <span class="ot">=</span> get key rest</span></code></pre></div>
 <p><br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br></p>
-<h2 id="a-json-datatype">A JSON Datatype</h2>
-<p>We can represent (a subset of) JSON values with the Haskell datatype</p>
-<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb36-1"><a href="#cb36-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">JVal</span></span>
-<span id="cb36-2"><a href="#cb36-2" aria-hidden="true" tabindex="-1"></a>  <span class="ot">=</span> <span class="dt">JStr</span>  <span class="dt">String</span></span>
-<span id="cb36-3"><a href="#cb36-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="dt">JNum</span>  <span class="dt">Double</span></span>
-<span id="cb36-4"><a href="#cb36-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="dt">JBool</span> <span class="dt">Bool</span></span>
-<span id="cb36-5"><a href="#cb36-5" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="dt">JObj</span>  [(<span class="dt">String</span>, <span class="dt">JVal</span>)]</span>
-<span id="cb36-6"><a href="#cb36-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="dt">JArr</span>  [<span class="dt">JVal</span>]</span>
-<span id="cb36-7"><a href="#cb36-7" aria-hidden="true" tabindex="-1"></a>  <span class="kw">deriving</span> (<span class="dt">Eq</span>, <span class="dt">Ord</span>, <span class="dt">Show</span>)</span></code></pre></div>
-<p><br>
-<br></p>
-<p>The above JSON value would be represented by the <code class="sourceCode haskell"><span class="dt">JVal</span></code></p>
-<div class="sourceCode" id="cb37"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb37-1"><a href="#cb37-1" aria-hidden="true" tabindex="-1"></a>js1 <span class="ot">=</span></span>
-<span id="cb37-2"><a href="#cb37-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">JObj</span> [(<span class="st">&quot;name&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;Nadia&quot;</span>)</span>
-<span id="cb37-3"><a href="#cb37-3" aria-hidden="true" tabindex="-1"></a>       ,(<span class="st">&quot;age&quot;</span>,  <span class="dt">JNum</span> <span class="fl">38.0</span>)</span>
-<span id="cb37-4"><a href="#cb37-4" aria-hidden="true" tabindex="-1"></a>       ,(<span class="st">&quot;likes&quot;</span>,   <span class="dt">JArr</span> [ <span class="dt">JStr</span> <span class="st">&quot;poke&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;coffee&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;pasta&quot;</span>])</span>
-<span id="cb37-5"><a href="#cb37-5" aria-hidden="true" tabindex="-1"></a>       ,(<span class="st">&quot;hates&quot;</span>,   <span class="dt">JArr</span> [ <span class="dt">JStr</span> <span class="st">&quot;beets&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;milk&quot;</span>])</span>
-<span id="cb37-6"><a href="#cb37-6" aria-hidden="true" tabindex="-1"></a>       ,(<span class="st">&quot;lunches&quot;</span>, <span class="dt">JArr</span> [ <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;mon&quot;</span>)</span>
-<span id="cb37-7"><a href="#cb37-7" aria-hidden="true" tabindex="-1"></a>                                ,(<span class="st">&quot;loc&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;fan fan&quot;</span>)]</span>
-<span id="cb37-8"><a href="#cb37-8" aria-hidden="true" tabindex="-1"></a>                         , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;tue&quot;</span>)</span>
-<span id="cb37-9"><a href="#cb37-9" aria-hidden="true" tabindex="-1"></a>                                ,(<span class="st">&quot;loc&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;home&quot;</span>)]</span>
-<span id="cb37-10"><a href="#cb37-10" aria-hidden="true" tabindex="-1"></a>                         , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;wed&quot;</span>)</span>
-<span id="cb37-11"><a href="#cb37-11" aria-hidden="true" tabindex="-1"></a>                                ,(<span class="st">&quot;loc&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;curry up now&quot;</span>)]</span>
-<span id="cb37-12"><a href="#cb37-12" aria-hidden="true" tabindex="-1"></a>                         , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;thu&quot;</span>)</span>
-<span id="cb37-13"><a href="#cb37-13" aria-hidden="true" tabindex="-1"></a>                                ,(<span class="st">&quot;loc&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;home&quot;</span>)]</span>
-<span id="cb37-14"><a href="#cb37-14" aria-hidden="true" tabindex="-1"></a>                         , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;fri&quot;</span>)</span>
-<span id="cb37-15"><a href="#cb37-15" aria-hidden="true" tabindex="-1"></a>                                ,(<span class="st">&quot;loc&quot;</span>,  <span class="dt">JStr</span> <span class="st">&quot;rubios&quot;</span>)]</span>
-<span id="cb37-16"><a href="#cb37-16" aria-hidden="true" tabindex="-1"></a>                         ])</span>
-<span id="cb37-17"><a href="#cb37-17" aria-hidden="true" tabindex="-1"></a>       ]  </span></code></pre></div>
-<p><br>
-<br>
-<br>
-<br>
-<br>
-<br>
 <br></p>
-<h2 id="serializing-haskell-values-to-json">Serializing Haskell Values to JSON</h2>
-<p>Lets write a small library to <em>serialize</em> Haskell values as JSON</p>
-<ul>
-<li>Base types <code class="sourceCode haskell"><span class="dt">String</span></code>, <code class="sourceCode haskell"><span class="dt">Double</span></code>, <code class="sourceCode haskell"><span class="dt">Bool</span></code> are serialized as base JSON values</li>
-<li>Lists are serialized into JSON arrays</li>
-<li>Lists of key-value pairs are serialized into JSON objects</li>
-</ul>
+<p>Let’s modify our implementation of fast dictionaries
+so that <code class="sourceCode haskell">get</code> returns a default value instead:</p>
+<div class="sourceCode" id="cb36"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb36-1"><a href="#cb36-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="dv">2</span>       (add <span class="dv">5</span> <span class="st">&quot;five&quot;</span>   (add <span class="dv">10</span> <span class="st">&quot;ten&quot;</span>  (add <span class="dv">3</span> <span class="st">&quot;three&quot;</span> <span class="dt">Empty</span>)))</span>
+<span id="cb36-2"><a href="#cb36-2" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;</span></span>
+<span id="cb36-3"><a href="#cb36-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb36-4"><a href="#cb36-4" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="st">&quot;horse&quot;</span> (add <span class="st">&quot;cat&quot;</span> <span class="fl">10.0</span> (add <span class="st">&quot;dog&quot;</span> <span class="fl">20.1</span> <span class="dt">Empty</span>))</span>
+<span id="cb36-5"><a href="#cb36-5" aria-hidden="true" tabindex="-1"></a><span class="fl">0.0</span></span></code></pre></div>
 <p><br>
 <br></p>
-<p>We could write a bunch of functions like</p>
-<div class="sourceCode" id="cb38"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb38-1"><a href="#cb38-1" aria-hidden="true" tabindex="-1"></a><span class="ot">doubleToJSON ::</span> <span class="dt">Double</span> <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb38-2"><a href="#cb38-2" aria-hidden="true" tabindex="-1"></a>doubleToJSON <span class="ot">=</span> <span class="dt">JNum</span></span>
-<span id="cb38-3"><a href="#cb38-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb38-4"><a href="#cb38-4" aria-hidden="true" tabindex="-1"></a><span class="ot">stringToJSON ::</span> <span class="dt">String</span> <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb38-5"><a href="#cb38-5" aria-hidden="true" tabindex="-1"></a>stringToJSON <span class="ot">=</span> <span class="dt">JStr</span></span>
-<span id="cb38-6"><a href="#cb38-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb38-7"><a href="#cb38-7" aria-hidden="true" tabindex="-1"></a><span class="ot">boolToJSON   ::</span> <span class="dt">Bool</span> <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb38-8"><a href="#cb38-8" aria-hidden="true" tabindex="-1"></a>boolToJSON   <span class="ot">=</span> <span class="dt">JBool</span></span></code></pre></div>
+<p>How can we achieve this?</p>
+<h3 id="option-1-add-an-argument-to-get">Option 1: add an argument to <code class="sourceCode haskell">get</code></h3>
+<div class="sourceCode" id="cb37"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb37-1"><a href="#cb37-1" aria-hidden="true" tabindex="-1"></a>get def key <span class="dt">Empty</span> <span class="ot">=</span> def</span>
+<span id="cb37-2"><a href="#cb37-2" aria-hidden="true" tabindex="-1"></a>get def key (<span class="dt">Bind</span> oldK v rest)</span>
+<span id="cb37-3"><a href="#cb37-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">&lt;</span> oldK     <span class="ot">=</span> def</span>
+<span id="cb37-4"><a href="#cb37-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="op">...</span></span></code></pre></div>
+<p>But then the client has to do:</p>
+<div class="sourceCode" id="cb38"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb38-1"><a href="#cb38-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> <span class="kw">let</span> dict <span class="ot">=</span> add <span class="dv">5</span> <span class="st">&quot;five&quot;</span>   (add <span class="dv">10</span> <span class="st">&quot;ten&quot;</span>  (add <span class="dv">3</span> <span class="st">&quot;three&quot;</span> <span class="dt">Empty</span>))</span>
+<span id="cb38-2"><a href="#cb38-2" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="st">&quot;&quot;</span> <span class="dv">2</span> dict</span>
+<span id="cb38-3"><a href="#cb38-3" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;</span></span>
+<span id="cb38-4"><a href="#cb38-4" aria-hidden="true" tabindex="-1"></a><span class="co">-- Need to pass in an extra argument every time! annoying!</span></span>
+<span id="cb38-5"><a href="#cb38-5" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="st">&quot;&quot;</span> <span class="dv">5</span> dict</span>
+<span id="cb38-6"><a href="#cb38-6" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;five&quot;</span></span></code></pre></div>
 <p><br>
 <br>
-<br>
-<br>
-<br>
-<br>
 <br></p>
-<h2 id="serializing-lists">Serializing Lists</h2>
-<p>But what about collections, namely <em>lists</em> of things?</p>
-<div class="sourceCode" id="cb39"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb39-1"><a href="#cb39-1" aria-hidden="true" tabindex="-1"></a><span class="ot">doublesToJSON    ::</span> [<span class="dt">Double</span>] <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb39-2"><a href="#cb39-2" aria-hidden="true" tabindex="-1"></a>doublesToJSON xs <span class="ot">=</span> <span class="dt">JArr</span> (<span class="fu">map</span> doubleToJSON xs)</span>
-<span id="cb39-3"><a href="#cb39-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb39-4"><a href="#cb39-4" aria-hidden="true" tabindex="-1"></a><span class="ot">boolsToJSON      ::</span> [<span class="dt">Bool</span>] <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb39-5"><a href="#cb39-5" aria-hidden="true" tabindex="-1"></a>boolsToJSON xs   <span class="ot">=</span> <span class="dt">JArr</span> (<span class="fu">map</span> boolToJSON xs)</span>
-<span id="cb39-6"><a href="#cb39-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb39-7"><a href="#cb39-7" aria-hidden="true" tabindex="-1"></a><span class="ot">stringsToJSON    ::</span> [<span class="dt">String</span>] <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb39-8"><a href="#cb39-8" aria-hidden="true" tabindex="-1"></a>stringsToJSON xs <span class="ot">=</span> <span class="dt">JArr</span> (<span class="fu">map</span> stringToJSON xs)</span></code></pre></div>
+<h3 id="option-2-store-the-default-value-in-the-dictionary">Option 2: store the default value in the dictionary</h3>
+<div class="sourceCode" id="cb39"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb39-1"><a href="#cb39-1" aria-hidden="true" tabindex="-1"></a><span class="kw">data</span> <span class="dt">Dict</span> k v</span>
+<span id="cb39-2"><a href="#cb39-2" aria-hidden="true" tabindex="-1"></a>  <span class="ot">=</span> <span class="dt">Empty</span> v               <span class="co">-- store the default value here</span></span>
+<span id="cb39-3"><a href="#cb39-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="dt">Bind</span> k v (<span class="dt">Dict</span> k v) v <span class="co">-- and maybe also here</span></span></code></pre></div>
+<p>Limitations?</p>
 <p><br>
-<br></p>
-<p>This is <strong>getting rather tedious</strong></p>
-<ul>
-<li>Lots of repetition :(</li>
-</ul>
-<p><br>
-<br>
 <br>
-<br>
-<br>
-<br></p>
-<h2 id="serializing-collections-refactored-with-hofs">Serializing Collections (refactored with HOFs)</h2>
-<p>You could abstract by making the <em>element-converter</em> a parameter</p>
-<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb40-1"><a href="#cb40-1" aria-hidden="true" tabindex="-1"></a><span class="ot">listToJSON ::</span> (a <span class="ot">-&gt;</span> <span class="dt">JVal</span>) <span class="ot">-&gt;</span> [a] <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb40-2"><a href="#cb40-2" aria-hidden="true" tabindex="-1"></a>listToJSON f xs <span class="ot">=</span> <span class="dt">JArr</span> (<span class="fu">map</span> f xs)</span>
-<span id="cb40-3"><a href="#cb40-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb40-4"><a href="#cb40-4" aria-hidden="true" tabindex="-1"></a><span class="ot">mapToJSON ::</span> (a <span class="ot">-&gt;</span> <span class="dt">JVal</span>) <span class="ot">-&gt;</span> [(<span class="dt">String</span>, a)] <span class="ot">-&gt;</span> <span class="dt">JVal</span></span>
-<span id="cb40-5"><a href="#cb40-5" aria-hidden="true" tabindex="-1"></a>mapToJSON f kvs <span class="ot">=</span> <span class="dt">JObj</span> [ (k, f v) <span class="op">|</span> (k, v) <span class="ot">&lt;-</span> kvs ]</span></code></pre></div>
-<p><br>
 <br></p>
-<p>But this is <em>still rather tedious</em> as you have to pass
-in the individual data converter (yuck)</p>
-<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb41-1"><a href="#cb41-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> doubleToJSON <span class="dv">4</span></span>
-<span id="cb41-2"><a href="#cb41-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JNum</span> <span class="fl">4.0</span></span>
+<h3 id="type-classes-to-the-rescue">Type Classes to the Rescue!</h3>
+<p>Would it be too much to ask for a magical <code class="sourceCode haskell">defValue</code>…</p>
+<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb40-1"><a href="#cb40-1" aria-hidden="true" tabindex="-1"></a>get def key <span class="dt">Empty</span> <span class="ot">=</span> defValue</span>
+<span id="cb40-2"><a href="#cb40-2" aria-hidden="true" tabindex="-1"></a>get def key (<span class="dt">Bind</span> oldK v rest)</span>
+<span id="cb40-3"><a href="#cb40-3" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">&lt;</span> oldK    <span class="ot">=</span> defValue</span>
+<span id="cb40-4"><a href="#cb40-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="op">...</span></span></code></pre></div>
+<p>… which has different values depending on the type of <code class="sourceCode haskell">v</code>?</p>
+<div class="sourceCode" id="cb41"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb41-1"><a href="#cb41-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="dv">2</span>       (add <span class="dv">5</span> <span class="st">&quot;five&quot;</span>   (add <span class="dv">10</span> <span class="st">&quot;ten&quot;</span>  (add <span class="dv">3</span> <span class="st">&quot;three&quot;</span> <span class="dt">Empty</span>)))</span>
+<span id="cb41-2"><a href="#cb41-2" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;</span> <span class="co">-- default value for strings</span></span>
 <span id="cb41-3"><a href="#cb41-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb41-4"><a href="#cb41-4" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> listToJSON stringToJSON [<span class="st">&quot;poke&quot;</span>, <span class="st">&quot;coffee&quot;</span>, <span class="st">&quot;pasta&quot;</span>]</span>
-<span id="cb41-5"><a href="#cb41-5" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [<span class="dt">JStr</span> <span class="st">&quot;poke&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;coffee&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;pasta&quot;</span>]</span>
-<span id="cb41-6"><a href="#cb41-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb41-7"><a href="#cb41-7" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> mapToJSON stringToJSON [(<span class="st">&quot;day&quot;</span>, <span class="st">&quot;mon&quot;</span>), (<span class="st">&quot;loc&quot;</span>, <span class="st">&quot;fan fan&quot;</span>)]</span>
-<span id="cb41-8"><a href="#cb41-8" aria-hidden="true" tabindex="-1"></a><span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;mon&quot;</span>),(<span class="st">&quot;loc&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;fan fan&quot;</span>)]</span></code></pre></div>
-<p><br>
-<br></p>
-<p>This gets more hideous when you have richer objects like</p>
-<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb42-1"><a href="#cb42-1" aria-hidden="true" tabindex="-1"></a>lunches <span class="ot">=</span> [ [(<span class="st">&quot;day&quot;</span>, <span class="st">&quot;mon&quot;</span>), (<span class="st">&quot;loc&quot;</span>, <span class="st">&quot;fan fan&quot;</span>)]</span>
-<span id="cb42-2"><a href="#cb42-2" aria-hidden="true" tabindex="-1"></a>          , [(<span class="st">&quot;day&quot;</span>, <span class="st">&quot;tue&quot;</span>), (<span class="st">&quot;loc&quot;</span>, <span class="st">&quot;home&quot;</span>)]</span>
-<span id="cb42-3"><a href="#cb42-3" aria-hidden="true" tabindex="-1"></a>          ]</span></code></pre></div>
-<p>because we have to go through gymnastics like</p>
-<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb43-1"><a href="#cb43-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> listToJSON (mapToJSON stringToJSON) lunches</span>
-<span id="cb43-2"><a href="#cb43-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [ <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;monday&quot;</span>)   ,(<span class="st">&quot;loc&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;fan fan&quot;</span>)]</span>
-<span id="cb43-3"><a href="#cb43-3" aria-hidden="true" tabindex="-1"></a>     , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;tuesday&quot;</span>)  ,(<span class="st">&quot;loc&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;home&quot;</span>)]</span>
-<span id="cb43-4"><a href="#cb43-4" aria-hidden="true" tabindex="-1"></a>     ]</span></code></pre></div>
-<p>Yikes. So much for <em>readability</em></p>
-<p>Is it too much to ask for a magical <code class="sourceCode haskell">toJSON</code> that <em>just works?</em></p>
+<span id="cb41-4"><a href="#cb41-4" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="st">&quot;horse&quot;</span> (add <span class="st">&quot;cat&quot;</span> <span class="fl">10.0</span> (add <span class="st">&quot;dog&quot;</span> <span class="fl">20.1</span> <span class="dt">Empty</span>))</span>
+<span id="cb41-5"><a href="#cb41-5" aria-hidden="true" tabindex="-1"></a><span class="fl">0.0</span> <span class="co">-- default value for floats</span></span></code></pre></div>
 <p><br>
 <br>
 <br>
-<br>
-<br>
-<br></p>
-<h2 id="typeclasses-to-the-rescue">Typeclasses To The Rescue</h2>
-<p>Lets <em>define</em> a typeclass that describes types <code class="sourceCode haskell">a</code> that can be converted to JSON.</p>
-<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb44-1"><a href="#cb44-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">JSON</span> a <span class="kw">where</span></span>
-<span id="cb44-2"><a href="#cb44-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  toJSON ::</span> a <span class="ot">-&gt;</span> <span class="dt">JVal</span></span></code></pre></div>
-<p>Now, just make all the above instances of <code class="sourceCode haskell"><span class="dt">JSON</span></code> like so</p>
-<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb45-1"><a href="#cb45-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">JSON</span> <span class="dt">Double</span> <span class="kw">where</span></span>
-<span id="cb45-2"><a href="#cb45-2" aria-hidden="true" tabindex="-1"></a>  toJSON <span class="ot">=</span> <span class="dt">JNum</span></span>
-<span id="cb45-3"><a href="#cb45-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb45-4"><a href="#cb45-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">JSON</span> <span class="dt">Bool</span> <span class="kw">where</span></span>
-<span id="cb45-5"><a href="#cb45-5" aria-hidden="true" tabindex="-1"></a>  toJSON <span class="ot">=</span> <span class="dt">JBool</span></span>
-<span id="cb45-6"><a href="#cb45-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb45-7"><a href="#cb45-7" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">JSON</span> <span class="dt">String</span> <span class="kw">where</span></span>
-<span id="cb45-8"><a href="#cb45-8" aria-hidden="true" tabindex="-1"></a>  toJSON <span class="ot">=</span> <span class="dt">JStr</span></span></code></pre></div>
-<p>This lets us uniformly write</p>
-<div class="sourceCode" id="cb46"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb46-1"><a href="#cb46-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON <span class="dv">4</span></span>
-<span id="cb46-2"><a href="#cb46-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JNum</span> <span class="fl">4.0</span></span>
-<span id="cb46-3"><a href="#cb46-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb46-4"><a href="#cb46-4" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON <span class="dt">True</span></span>
-<span id="cb46-5"><a href="#cb46-5" aria-hidden="true" tabindex="-1"></a><span class="dt">JBool</span> <span class="dt">True</span></span>
-<span id="cb46-6"><a href="#cb46-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb46-7"><a href="#cb46-7" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON <span class="st">&quot;guacamole&quot;</span></span>
-<span id="cb46-8"><a href="#cb46-8" aria-hidden="true" tabindex="-1"></a><span class="dt">JStr</span> <span class="st">&quot;guacamole&quot;</span></span></code></pre></div>
-<p><br>
-<br>
-<br>
-<br>
-<br>
-<br></p>
-<h2 id="bootstrapping-instances">Bootstrapping Instances</h2>
-<p>The real fun begins when we get Haskell to automatically
-bootstrap the above functions to work for lists and key-value lists!</p>
-<div class="sourceCode" id="cb47"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb47-1"><a href="#cb47-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">JSON</span> a <span class="ot">=&gt;</span> <span class="dt">JSON</span> [a] <span class="kw">where</span></span>
-<span id="cb47-2"><a href="#cb47-2" aria-hidden="true" tabindex="-1"></a>  toJSON xs <span class="ot">=</span> <span class="dt">JArr</span> [toJSON x <span class="op">|</span> x <span class="ot">&lt;-</span> xs]</span></code></pre></div>
-<p>The above says, if <code class="sourceCode haskell">a</code> is an instance of <code class="sourceCode haskell"><span class="dt">JSON</span></code>, that is,
-if you can convert <code class="sourceCode haskell">a</code> to <code class="sourceCode haskell"><span class="dt">JVal</span></code> then here’s a generic
-recipe to convert lists of <code class="sourceCode haskell">a</code> values!</p>
-<div class="sourceCode" id="cb48"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb48-1"><a href="#cb48-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON [<span class="dt">True</span>, <span class="dt">False</span>, <span class="dt">True</span>]</span>
-<span id="cb48-2"><a href="#cb48-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [<span class="dt">JBln</span> <span class="dt">True</span>, <span class="dt">JBln</span> <span class="dt">False</span>, <span class="dt">JBln</span> <span class="dt">True</span>]</span>
-<span id="cb48-3"><a href="#cb48-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb48-4"><a href="#cb48-4" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON [<span class="st">&quot;cat&quot;</span>, <span class="st">&quot;dog&quot;</span>, <span class="st">&quot;Mouse&quot;</span>]</span>
-<span id="cb48-5"><a href="#cb48-5" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [<span class="dt">JStr</span> <span class="st">&quot;cat&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;dog&quot;</span>, <span class="dt">JStr</span> <span class="st">&quot;Mouse&quot;</span>]</span></code></pre></div>
-<p>or even lists-of-lists!</p>
-<div class="sourceCode" id="cb49"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb49-1"><a href="#cb49-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON [[<span class="st">&quot;cat&quot;</span>, <span class="st">&quot;dog&quot;</span>], [<span class="st">&quot;mouse&quot;</span>, <span class="st">&quot;rabbit&quot;</span>]]</span>
-<span id="cb49-2"><a href="#cb49-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [<span class="dt">JArr</span> [<span class="dt">JStr</span> <span class="st">&quot;cat&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;dog&quot;</span>],<span class="dt">JArr</span> [<span class="dt">JStr</span> <span class="st">&quot;mouse&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;rabbit&quot;</span>]]</span></code></pre></div>
-<p>We can pull the same trick with key-value lists</p>
-<div class="sourceCode" id="cb50"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb50-1"><a href="#cb50-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> (<span class="dt">JSON</span> a) <span class="ot">=&gt;</span> <span class="dt">JSON</span> [(<span class="dt">String</span>, a)] <span class="kw">where</span></span>
-<span id="cb50-2"><a href="#cb50-2" aria-hidden="true" tabindex="-1"></a>  toJSON kvs <span class="ot">=</span> <span class="dt">JObj</span> [ (k, toJSON v) <span class="op">|</span> (k, v) <span class="ot">&lt;-</span> kvs ]</span></code></pre></div>
-<p>after which, we are all set!</p>
-<div class="sourceCode" id="cb51"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb51-1"><a href="#cb51-1" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> toJSON lunches</span>
-<span id="cb51-2"><a href="#cb51-2" aria-hidden="true" tabindex="-1"></a><span class="dt">JArr</span> [ <span class="dt">JObj</span> [ (<span class="st">&quot;day&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;monday&quot;</span>), (<span class="st">&quot;loc&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;zanzibar&quot;</span>)]</span>
-<span id="cb51-3"><a href="#cb51-3" aria-hidden="true" tabindex="-1"></a>     , <span class="dt">JObj</span> [(<span class="st">&quot;day&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;tuesday&quot;</span>), (<span class="st">&quot;loc&quot;</span>,<span class="dt">JStr</span> <span class="st">&quot;farmers market&quot;</span>)]</span>
-<span id="cb51-4"><a href="#cb51-4" aria-hidden="true" tabindex="-1"></a>     ]</span></code></pre></div>
-<p><br>
-<br>
 <br></p>
-<p>It is also useful to bootstrap the serialization for tuples (upto some
-fixed size) so we can easily write “non-uniform” JSON objects where keys
-are bound to values with different shapes.</p>
-<div class="sourceCode" id="cb52"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb52-1"><a href="#cb52-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> (<span class="dt">JSON</span> a, <span class="dt">JSON</span> b) <span class="ot">=&gt;</span> <span class="dt">JSON</span> ((<span class="dt">String</span>, a), (<span class="dt">String</span>, b)) <span class="kw">where</span></span>
-<span id="cb52-2"><a href="#cb52-2" aria-hidden="true" tabindex="-1"></a>  toJSON ((k1, v1), (k2, v2)) <span class="ot">=</span></span>
-<span id="cb52-3"><a href="#cb52-3" aria-hidden="true" tabindex="-1"></a>    <span class="dt">JObj</span> [(k1, toJSON v1), (k2, toJSON v2)]</span>
-<span id="cb52-4"><a href="#cb52-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb52-5"><a href="#cb52-5" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> (<span class="dt">JSON</span> a, <span class="dt">JSON</span> b, <span class="dt">JSON</span> c) <span class="ot">=&gt;</span> <span class="dt">JSON</span> ((<span class="dt">String</span>, a), (<span class="dt">String</span>, b), (<span class="dt">String</span>, c)) <span class="kw">where</span></span>
-<span id="cb52-6"><a href="#cb52-6" aria-hidden="true" tabindex="-1"></a>  toJSON ((k1, v1), (k2, v2), (k3, v3)) <span class="ot">=</span></span>
-<span id="cb52-7"><a href="#cb52-7" aria-hidden="true" tabindex="-1"></a>    <span class="dt">JObj</span> [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3)]</span>
-<span id="cb52-8"><a href="#cb52-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb52-9"><a href="#cb52-9" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> (<span class="dt">JSON</span> a, <span class="dt">JSON</span> b, <span class="dt">JSON</span> c, <span class="dt">JSON</span> d) <span class="ot">=&gt;</span> <span class="dt">JSON</span> ((<span class="dt">String</span>, a), (<span class="dt">String</span>, b), (<span class="dt">String</span>, c), (<span class="dt">String</span>,d)) <span class="kw">where</span></span>
-<span id="cb52-10"><a href="#cb52-10" aria-hidden="true" tabindex="-1"></a>  toJSON ((k1, v1), (k2, v2), (k3, v3), (k4, v4)) <span class="ot">=</span></span>
-<span id="cb52-11"><a href="#cb52-11" aria-hidden="true" tabindex="-1"></a>    <span class="dt">JObj</span> [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3), (k4, toJSON v4)]</span>
-<span id="cb52-12"><a href="#cb52-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb52-13"><a href="#cb52-13" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> (<span class="dt">JSON</span> a, <span class="dt">JSON</span> b, <span class="dt">JSON</span> c, <span class="dt">JSON</span> d, <span class="dt">JSON</span> e) <span class="ot">=&gt;</span> <span class="dt">JSON</span> ((<span class="dt">String</span>, a), (<span class="dt">String</span>, b), (<span class="dt">String</span>, c), (<span class="dt">String</span>,d), (<span class="dt">String</span>, e)) <span class="kw">where</span></span>
-<span id="cb52-14"><a href="#cb52-14" aria-hidden="true" tabindex="-1"></a>  toJSON ((k1, v1), (k2, v2), (k3, v3), (k4, v4), (k5, v5)) <span class="ot">=</span></span>
-<span id="cb52-15"><a href="#cb52-15" aria-hidden="true" tabindex="-1"></a>    <span class="dt">JObj</span> [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3), (k4, toJSON v4), (k5, toJSON v5)]</span></code></pre></div>
-<p>Now, we can simply write</p>
-<div class="sourceCode" id="cb53"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb53-1"><a href="#cb53-1" aria-hidden="true" tabindex="-1"></a>hs <span class="ot">=</span> ((<span class="st">&quot;name&quot;</span>   , <span class="st">&quot;Nadia&quot;</span>)</span>
-<span id="cb53-2"><a href="#cb53-2" aria-hidden="true" tabindex="-1"></a>     ,(<span class="st">&quot;age&quot;</span>    , <span class="fl">38.0</span>)</span>
-<span id="cb53-3"><a href="#cb53-3" aria-hidden="true" tabindex="-1"></a>     ,(<span class="st">&quot;likes&quot;</span>  , [<span class="st">&quot;poke&quot;</span>, <span class="st">&quot;coffee&quot;</span>, <span class="st">&quot;pasta&quot;</span>])</span>
-<span id="cb53-4"><a href="#cb53-4" aria-hidden="true" tabindex="-1"></a>     ,(<span class="st">&quot;hates&quot;</span>  , [<span class="st">&quot;beets&quot;</span>, <span class="st">&quot;milk&quot;</span>])</span>
-<span id="cb53-5"><a href="#cb53-5" aria-hidden="true" tabindex="-1"></a>     ,(<span class="st">&quot;lunches&quot;</span>, lunches)</span>
-<span id="cb53-6"><a href="#cb53-6" aria-hidden="true" tabindex="-1"></a>     )     </span></code></pre></div>
-<p>which is a Haskell value that describes our running JSON example,
-and can convert it directly like so</p>
-<div class="sourceCode" id="cb54"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb54-1"><a href="#cb54-1" aria-hidden="true" tabindex="-1"></a>js2 <span class="ot">=</span> toJSON hs</span></code></pre></div>
+<p>That’s what type classes are for!</p>
+<div class="sourceCode" id="cb42"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb42-1"><a href="#cb42-1" aria-hidden="true" tabindex="-1"></a><span class="co">-- (&lt;) is a magical function </span></span>
+<span id="cb42-2"><a href="#cb42-2" aria-hidden="true" tabindex="-1"></a><span class="co">-- with different implementations depending on the argument type:</span></span>
+<span id="cb42-3"><a href="#cb42-3" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> <span class="dv">1</span> <span class="op">&lt;</span> <span class="dv">2</span></span>
+<span id="cb42-4"><a href="#cb42-4" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span>
+<span id="cb42-5"><a href="#cb42-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb42-6"><a href="#cb42-6" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> <span class="st">&quot;cat&quot;</span> <span class="op">&lt;</span> <span class="st">&quot;dog&quot;</span></span>
+<span id="cb42-7"><a href="#cb42-7" aria-hidden="true" tabindex="-1"></a><span class="dt">True</span></span></code></pre></div>
 <p><br>
 <br>
 <br>
 <br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
 <br></p>
-<h2 id="exercise-dictionary-with-default-values">EXERCISE: Dictionary with Default Values</h2>
-<p>Modify our implementation of fast dictionaries
-so that <code class="sourceCode haskell">get</code> returns a default value if the key is not found.</p>
-<p>You should get the following behavior:</p>
-<div class="sourceCode" id="cb55"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb55-1"><a href="#cb55-1" aria-hidden="true" tabindex="-1"></a><span class="co">-- Note: the default value is NOT passed into `get`</span></span>
-<span id="cb55-2"><a href="#cb55-2" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="dv">2</span>       (add <span class="dv">5</span> <span class="st">&quot;five&quot;</span>   (add <span class="dv">10</span> <span class="st">&quot;ten&quot;</span>  (add <span class="dv">3</span> <span class="st">&quot;three&quot;</span> empty)))</span>
-<span id="cb55-3"><a href="#cb55-3" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;</span></span>
-<span id="cb55-4"><a href="#cb55-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb55-5"><a href="#cb55-5" aria-hidden="true" tabindex="-1"></a>λ<span class="op">&gt;</span> get <span class="st">&quot;horse&quot;</span> (add <span class="st">&quot;cat&quot;</span> <span class="fl">10.0</span> (add <span class="st">&quot;dog&quot;</span> <span class="fl">20.1</span> empty))</span>
-<span id="cb55-6"><a href="#cb55-6" aria-hidden="true" tabindex="-1"></a><span class="fl">0.0</span></span></code></pre></div>
+<h2 id="type-class-for-default-values">Type Class for Default Values</h2>
+<div class="sourceCode" id="cb43"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb43-1"><a href="#cb43-1" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> <span class="dt">Default</span> a <span class="kw">where</span></span>
+<span id="cb43-2"><a href="#cb43-2" aria-hidden="true" tabindex="-1"></a><span class="ot">  defValue ::</span> a</span></code></pre></div>
+<p>Now we need to tell <code class="sourceCode haskell">get</code> that <code class="sourceCode haskell">v</code> has a default value:</p>
+<div class="sourceCode" id="cb44"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb44-1"><a href="#cb44-1" aria-hidden="true" tabindex="-1"></a><span class="ot">get ::</span> (<span class="dt">Ord</span> k, <span class="dt">Default</span> v) <span class="ot">=&gt;</span> k <span class="ot">-&gt;</span> <span class="dt">Dict</span> k v <span class="ot">-&gt;</span> v</span>
+<span id="cb44-2"><a href="#cb44-2" aria-hidden="true" tabindex="-1"></a>get key <span class="dt">Empty</span> <span class="ot">=</span> defValue <span class="co">-- uses the method of the Default class!</span></span>
+<span id="cb44-3"><a href="#cb44-3" aria-hidden="true" tabindex="-1"></a>get key (<span class="dt">Bind</span> oldK v rest)</span>
+<span id="cb44-4"><a href="#cb44-4" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">&lt;</span> oldK    <span class="ot">=</span> defValue</span>
+<span id="cb44-5"><a href="#cb44-5" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> key <span class="op">==</span> oldK   <span class="ot">=</span> v</span>
+<span id="cb44-6"><a href="#cb44-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">|</span> <span class="fu">otherwise</span>     <span class="ot">=</span> get key rest</span></code></pre></div>
+<p>Finally, we need to define instances of <code class="sourceCode haskell"><span class="dt">Default</span></code> for different value types:</p>
+<div class="sourceCode" id="cb45"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb45-1"><a href="#cb45-1" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Default</span> <span class="dt">Int</span> <span class="kw">where</span></span>
+<span id="cb45-2"><a href="#cb45-2" aria-hidden="true" tabindex="-1"></a>  defValue <span class="ot">=</span> <span class="dv">0</span></span>
+<span id="cb45-3"><a href="#cb45-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb45-4"><a href="#cb45-4" aria-hidden="true" tabindex="-1"></a><span class="kw">instance</span> <span class="dt">Default</span> [a] <span class="kw">where</span></span>
+<span id="cb45-5"><a href="#cb45-5" aria-hidden="true" tabindex="-1"></a>  defValue <span class="ot">=</span> []</span></code></pre></div>
 <p><br>
 <br>
 <br>
@@ -1330,9 +1161,6 @@ <h2 id="exercise-dictionary-with-default-values">EXERCISE: Dictionary with Defau
 <br>
 <br>
 <br>
-<br>
-<br>
-<br>
 <br></p>
 <p>That’s all folks!</p>
                 <hr>
diff --git a/lectures/07-classes.md b/lectures/07-classes.md
index be92f9c..b659ec5 100644
--- a/lectures/07-classes.md
+++ b/lectures/07-classes.md
@@ -977,7 +977,7 @@ How, did GHC figure this out?
 <br>
 <br>
 
-## TRY AT HOME: A Faster Dictionary
+## EXERCISE: A Faster Dictionary
 
 Write an optimized version of
 
@@ -1124,370 +1124,146 @@ Lets conclude today's class with a quick example that provides a taste.
 <br>
 <br>
 <br>
- 
-
-## JSON
-
-*JavaScript Object Notation* or [JSON](http://www.json.org/) is a simple format for
-transferring data around. Here is an example:
-
-```json
-{ "name"    : "Nadia"
-, "age"     : 39.0
-, "likes"   : [ "poke", "tea", "pasta" ]
-, "hates"   : [ "beets" , "milk" ]
-, "lunches" : [ {"day" : "mon", "loc" : "fan fan"}
-              , {"day" : "tue", "loc" : "home"}
-              , {"day" : "wed", "loc" : "curry up now"}
-              , {"day" : "thu", "loc" : "home"}
-              , {"day" : "fri", "loc" : "rubios"} ]
-}
-```
-
-Each JSON value is either
-
-- a *base* value like a string, a number or a boolean,
-
-- an (ordered) *array* of values, or
-
-- an *object*, i.e. a set of *string-value* pairs.
-
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-
-## A JSON Datatype
-
-We can represent (a subset of) JSON values with the Haskell datatype
 
-```haskell
-data JVal
-  = JStr  String
-  | JNum  Double
-  | JBool Bool
-  | JObj  [(String, JVal)]
-  | JArr  [JVal]
-  deriving (Eq, Ord, Show)
-```
+## Dictionary with Default Values
 
-<br>
-<br>
 
-The above JSON value would be represented by the `JVal`
+Recall that our `get` function throws an error when the key is not found:
 
 ```haskell
-js1 =
-  JObj [("name", JStr "Nadia")
-       ,("age",  JNum 38.0)
-       ,("likes",   JArr [ JStr "poke", JStr "coffee", JStr "pasta"])
-       ,("hates",   JArr [ JStr "beets", JStr "milk"])
-       ,("lunches", JArr [ JObj [("day",  JStr "mon")
-                                ,("loc",  JStr "fan fan")]
-                         , JObj [("day",  JStr "tue")
-                                ,("loc",  JStr "home")]
-                         , JObj [("day",  JStr "wed")
-                                ,("loc",  JStr "curry up now")]
-                         , JObj [("day",  JStr "thu")
-                                ,("loc",  JStr "home")]
-                         , JObj [("day",  JStr "fri")
-                                ,("loc",  JStr "rubios")]
-                         ])
-       ]  
+get key Empty      = error "key not found"
+get key (Bind oldK v rest)
+  | key == oldK    = v
+  | key < oldK     = error "key not found"
+  | otherwise      = get key rest
 ```
 
-<br>
-<br>
-<br>
-<br>
-<br>
 <br>
 <br>
 
-## Serializing Haskell Values to JSON
-
-Lets write a small library to _serialize_ Haskell values as JSON
-
-  - Base types `String`, `Double`, `Bool` are serialized as base JSON values
-  - Lists are serialized into JSON arrays
-  - Lists of key-value pairs are serialized into JSON objects
+Let's modify our implementation of fast dictionaries
+so that `get` returns a default value instead:
   
-<br>
-<br>  
-
-We could write a bunch of functions like
-
 ```haskell
-doubleToJSON :: Double -> JVal
-doubleToJSON = JNum
-
-stringToJSON :: String -> JVal
-stringToJSON = JStr
+λ> get 2       (add 5 "five"   (add 10 "ten"  (add 3 "three" Empty)))
+""
 
-boolToJSON   :: Bool -> JVal
-boolToJSON   = JBool
+λ> get "horse" (add "cat" 10.0 (add "dog" 20.1 Empty))
+0.0
 ```
 
-<br>
-<br>
-<br>
-<br>
-<br>
 <br>
 <br>
 
-## Serializing Lists
+How can we achieve this?
 
-But what about collections, namely _lists_ of things?
+### Option 1: add an argument to `get`
 
 ```haskell
-doublesToJSON    :: [Double] -> JVal
-doublesToJSON xs = JArr (map doubleToJSON xs)
-
-boolsToJSON      :: [Bool] -> JVal
-boolsToJSON xs   = JArr (map boolToJSON xs)
-
-stringsToJSON    :: [String] -> JVal
-stringsToJSON xs = JArr (map stringToJSON xs)
+get def key Empty = def
+get def key (Bind oldK v rest)
+  | key < oldK     = def
+  | ...
 ```
 
-<br>
-<br>
-
-This is **getting rather tedious**
-
-- Lots of repetition :(
-
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-
-## Serializing Collections (refactored with HOFs)
-
-You could abstract by making the *element-converter* a parameter
+But then the client has to do:
 
 ```haskell
-listToJSON :: (a -> JVal) -> [a] -> JVal
-listToJSON f xs = JArr (map f xs)
-
-mapToJSON :: (a -> JVal) -> [(String, a)] -> JVal
-mapToJSON f kvs = JObj [ (k, f v) | (k, v) <- kvs ]
+λ> let dict = add 5 "five"   (add 10 "ten"  (add 3 "three" Empty))
+λ> get "" 2 dict
+""
+-- Need to pass in an extra argument every time! annoying!
+λ> get "" 5 dict
+"five"
 ```
 
 <br>
 <br>
-
-But this is *still rather tedious* as you have to pass 
-in the individual data converter (yuck)
-
-```haskell
-λ> doubleToJSON 4
-JNum 4.0
-
-λ> listToJSON stringToJSON ["poke", "coffee", "pasta"]
-JArr [JStr "poke",JStr "coffee",JStr "pasta"]
-
-λ> mapToJSON stringToJSON [("day", "mon"), ("loc", "fan fan")]
-JObj [("day",JStr "mon"),("loc",JStr "fan fan")]
-```
-<br>
 <br>
 
-This gets more hideous when you have richer objects like
-
-```haskell
-lunches = [ [("day", "mon"), ("loc", "fan fan")]
-          , [("day", "tue"), ("loc", "home")]
-          ]
-```
-
-because we have to go through gymnastics like
+### Option 2: store the default value in the dictionary
 
 ```haskell
-λ> listToJSON (mapToJSON stringToJSON) lunches
-JArr [ JObj [("day",JStr "monday")   ,("loc",JStr "fan fan")]
-     , JObj [("day",JStr "tuesday")  ,("loc",JStr "home")]
-     ]
+data Dict k v
+  = Empty v               -- store the default value here
+  | Bind k v (Dict k v) v -- and maybe also here
 ```
 
-Yikes. So much for _readability_
-
-Is it too much to ask for a magical `toJSON` that _just works?_
+Limitations?
 
-<br>
-<br>
-<br>
 <br>
 <br>
 <br>
 
-## Typeclasses To The Rescue
+### Type Classes to the Rescue!
 
-Lets _define_ a typeclass that describes types `a` that can be converted to JSON.
+Would it be too much to ask for a magical `defValue`...
 
 ```haskell
-class JSON a where
-  toJSON :: a -> JVal
+get def key Empty = defValue
+get def key (Bind oldK v rest)
+  | key < oldK    = defValue
+  | ...
 ```
 
-Now, just make all the above instances of `JSON` like so
+... which has different values depending on the type of `v`?
 
 ```haskell
-instance JSON Double where
-  toJSON = JNum
+λ> get 2       (add 5 "five"   (add 10 "ten"  (add 3 "three" Empty)))
+"" -- default value for strings
 
-instance JSON Bool where
-  toJSON = JBool
-
-instance JSON String where
-  toJSON = JStr
+λ> get "horse" (add "cat" 10.0 (add "dog" 20.1 Empty))
+0.0 -- default value for floats
 ```
 
-This lets us uniformly write
-
-```haskell
-λ> toJSON 4
-JNum 4.0
-
-λ> toJSON True
-JBool True
-
-λ> toJSON "guacamole"
-JStr "guacamole"
-```
-<br>
-<br>
 <br>
 <br>
 <br>
 <br>
 
-## Bootstrapping Instances
-
-The real fun begins when we get Haskell to automatically
-bootstrap the above functions to work for lists and key-value lists!
-
-```haskell
-instance JSON a => JSON [a] where
-  toJSON xs = JArr [toJSON x | x <- xs]
-```
-
-The above says, if `a` is an instance of `JSON`, that is,
-if you can convert `a` to `JVal` then here's a generic
-recipe to convert lists of `a` values!
-
-```haskell
-λ> toJSON [True, False, True]
-JArr [JBln True, JBln False, JBln True]
-
-λ> toJSON ["cat", "dog", "Mouse"]
-JArr [JStr "cat", JStr "dog", JStr "Mouse"]
-```
-
-or even lists-of-lists!
-
-```haskell
-λ> toJSON [["cat", "dog"], ["mouse", "rabbit"]]
-JArr [JArr [JStr "cat",JStr "dog"],JArr [JStr "mouse",JStr "rabbit"]]
-```
-
-We can pull the same trick with key-value lists
-
+That's what type classes are for!
+  
 ```haskell
-instance (JSON a) => JSON [(String, a)] where
-  toJSON kvs = JObj [ (k, toJSON v) | (k, v) <- kvs ]
-```
-
-after which, we are all set!
+-- (<) is a magical function 
+-- with different implementations depending on the argument type:
+λ> 1 < 2
+True
 
-```haskell
-λ> toJSON lunches
-JArr [ JObj [ ("day",JStr "monday"), ("loc",JStr "zanzibar")]
-     , JObj [("day",JStr "tuesday"), ("loc",JStr "farmers market")]
-     ]
+λ> "cat" < "dog"
+True
 ```
-
+<br>
+<br>
 <br>
 <br>
 <br>
 
-It is also useful to bootstrap the serialization for tuples (upto some
-fixed size) so we can easily write "non-uniform" JSON objects where keys
-are bound to values with different shapes.
-
-```haskell
-instance (JSON a, JSON b) => JSON ((String, a), (String, b)) where
-  toJSON ((k1, v1), (k2, v2)) =
-    JObj [(k1, toJSON v1), (k2, toJSON v2)]
-
-instance (JSON a, JSON b, JSON c) => JSON ((String, a), (String, b), (String, c)) where
-  toJSON ((k1, v1), (k2, v2), (k3, v3)) =
-    JObj [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3)]
-
-instance (JSON a, JSON b, JSON c, JSON d) => JSON ((String, a), (String, b), (String, c), (String,d)) where
-  toJSON ((k1, v1), (k2, v2), (k3, v3), (k4, v4)) =
-    JObj [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3), (k4, toJSON v4)]
-
-instance (JSON a, JSON b, JSON c, JSON d, JSON e) => JSON ((String, a), (String, b), (String, c), (String,d), (String, e)) where
-  toJSON ((k1, v1), (k2, v2), (k3, v3), (k4, v4), (k5, v5)) =
-    JObj [(k1, toJSON v1), (k2, toJSON v2), (k3, toJSON v3), (k4, toJSON v4), (k5, toJSON v5)]
-``` 
-
-Now, we can simply write
+## Type Class for Default Values
 
 ```haskell
-hs = (("name"   , "Nadia")
-     ,("age"    , 38.0)
-     ,("likes"  , ["poke", "coffee", "pasta"])
-     ,("hates"  , ["beets", "milk"])
-     ,("lunches", lunches)
-     )     
+class Default a where
+  defValue :: a
 ```
 
-which is a Haskell value that describes our running JSON example, 
-and can convert it directly like so
+Now we need to tell `get` that `v` has a default value:
 
 ```haskell
-js2 = toJSON hs
+get :: (Ord k, Default v) => k -> Dict k v -> v
+get key Empty = defValue -- uses the method of the Default class!
+get key (Bind oldK v rest)
+  | key < oldK    = defValue
+  | key == oldK   = v
+  | otherwise     = get key rest
 ```
 
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-<br>
-
-## EXERCISE: Dictionary with Default Values
-
-Modify our implementation of fast dictionaries
-so that `get` returns a default value if the key is not found.
+Finally, we need to define instances of `Default` for different value types:
 
-You should get the following behavior:
-  
 ```haskell
--- Note: the default value is NOT passed into `get`
-λ> get 2       (add 5 "five"   (add 10 "ten"  (add 3 "three" empty)))
-""
+instance Default Int where
+  defValue = 0
 
-λ> get "horse" (add "cat" 10.0 (add "dog" 20.1 empty))
-0.0
+instance Default [a] where
+  defValue = []
 ```
 
 <br>
@@ -1503,9 +1279,6 @@ You should get the following behavior:
 <br>
 <br>
 <br>
-<br>
-<br>
-<br>
 
 
 That's all folks! 
\ No newline at end of file
diff --git a/lectures/info_ocaml.md b/lectures/info_ocaml.md
deleted file mode 100644
index 5e1bc8b..0000000
--- a/lectures/info_ocaml.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: How to run Ocaml in the Lab machines
-headerImg: books.jpg
----
-
-## Entering the Ocaml Shell
-
-You need to type `prep cs130s` before you can run `Ocaml`.
-
-Here is a sample session.
-
-```bash
-$ prep cs130s
-
-$ ocaml
-        OCaml version 4.02.3
-
-# 2 + 3;;
-- : int = 5
-
-# Printf.printf "Hello, %s \n" "world" ;;
-Hello, world
-- : unit = ()
-```
-
-If you run `Ocaml` on your _own_ machine, then do 
-
-```bash
-$ rlwrap ocaml
-```
-
-The `rlwrap` is **optional** but rather nice as it lets you
-hit the up/down cursors to go to your old commands (to avoid
-typing them out again.) We have used `alias` so you don't have
-to type it out on `ieng6`.
-
-
-## Loading Files
-
-Enter
-
-```ocaml
-#use "foo.ml";;
-```
-
-to `load` the file `foo.ml`.
-This has the same effect as
-typing out the file at the
-prompt, but its usually more
-convenient to type and edit
-the file with Vim/Emacs/Atom
-and load it in like this.
-(A more convenient option is
-the OCaml-mode for Emacs.)
-
-Press `Ctrl-D` to exit OCaml.
-
-## Directly Running Ocaml from Bash
-
-You can directly _run_ the file,
-i.e. send the file `foo.ml` into
-OCaml and get the output piped
-to `stdout` by typing:
-
-```bash
-$ ocaml foo.ml
-```
diff --git a/lectures/info_prolog.md b/lectures/info_prolog.md
deleted file mode 100644
index 25905ca..0000000
--- a/lectures/info_prolog.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: How to run Prolog in the Lab machines
-headerImg: books.jpg
----
-
-
-## Entering the Prolog Shell
-
-Here is a sample session. We use `$` for the Unix shell prompt, and `?-` for
-the Prolog shell prompt.
-
-~~~~~{.prolog}
-$ rlwrap swipl
-
-130f@ieng6-202]:~:501$ swipl
-Welcome to SWI-Prolog (Multi-threaded, 32 bits, Version 5.10.5)
-Copyright (c) 1990-2011 University of Amsterdam, VU Amsterdam
-SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software,
-and you are welcome to redistribute it under certain conditions.
-Please visit http://www.swi-prolog.org for details.
-
-For help, use ?- help(Topic). or ?- apropos(Word).
-
-?- X = cat.
-X = cat.
-
-?- X = Y.
-X = Y.
-
-?- halt.
-~~~~~
-
-To **load** a program [lec-prolog.pl](/lectures/lec-prolog.pl)  from disk use the `consult` command like so:
-
-~~~~~{.prolog}
-?- consult('lec-prolog.pl').
-% foo.pl compiled 0.00 sec, 10,640 bytes
-true.
-
-?- parent(albert, z).
-false.
-
-?- parent(albert, Z).
-Z = felix ;
-Z = dana.
-
-?- parent(Z, dana).
-Z = albert ;
-false.
-~~~~~
diff --git a/lectures/partial-solutions.md b/lectures/partial-solutions.md
deleted file mode 100644
index bb92da5..0000000
--- a/lectures/partial-solutions.md
+++ /dev/null
@@ -1,218 +0,0 @@
----
-title: Partial Solution Key For Sample Exams
-headerImg: books.jpg
----
-
-## Final Fall 06
-
-### 6 (a)
-
-~~~~~{.scala}
-def elementAndRest[A](xs: List[A]): Iterator[(A, List[A])] = {
-  for (i <- (0 until xs.length).iterator)
-    yield (xs(i), xs.slice(0, i) ++ xs.slice(i+1, xs.length))
-}
-~~~~~
-
-### 6 (b)
-
-~~~~~{.scala}
-def permutations[A](xs: List[A]): Iterator[List[A]] =
-  xs match {
-    case Nil     =>
-      Iterator(List())
-    case x::rest =>
-      for ( ys <- permutations(rest)
-          ; i  <- 0 until xs.length)
-      yield ys.slice(0, i) ++ List(x) ++ ys.slice(i, ys.length)
-  }
-~~~~~
-
-## Fall 07
-
-### 6 (d)
-
-~~~~~{.scala}
-object tick {
-  private var ctr = 0
-  def apply() = {
-    ctr += 1
-    ctr
-  }
-}
-~~~~~
-
-### 7 (a)
-
-~~~~~{.scala}
-def valid(es:List[(Int, Int)], c: List[Int]): Boolean =
-  es.forall(e => c(e._1) != c(e._2))
-~~~~~
-
-
-### 7 (b)
-
-~~~~~{.scala}
-def colorings(n: Int, k: Int): List[List[Int]] = {
-  if (n <= 0) List(List())
-  else { for ( cs <- colorings(n-1, k)
-             ;  c <- 0 until k)
-         yield (c::cs) }
-}
-
-~~~~~
-
-### 7 (c)
-
-~~~~~{.scala}
-def initColoring(n: Int) =
-  (0 until n).toList.map(x => 0)
-
-def lastColoring(xs: List[Int], k: Int) =
-  xs.forall(_ == k-1)
-
-def nextColoring(xs: List[Int], k: Int) = {
-  var res : List[Int] = List()
-  var carry = 1
-  for (i <- (xs.length - 1) to 0 by -1) {
-    val sum = carry + xs(i)
-    val dig = sum % k
-    carry   = sum / k
-    res     = dig :: res
-  }
-  res
-}
-~~~~~
-
-
-## Midterm Spring 12
-
-### 1 (a)
-
-~~~~~{.ocaml}
-val (<.>) : ('b -> 'c) -> ('a -> 'b) -> ('a -> 'c)
-~~~~~
-
-### 1 (b)
-
-~~~~~{.ocaml}
-10
-~~~~~
-
-### 1 (c)
-
-~~~~~{.scala}
-let giftList =
-  let rec helper acc xs = match xs with
-    | []     -> acc^" and thats what I want for Christmas!"
-    | x::xs' -> helper (acc ^ " and ") xs'
-  in helper ""
-~~~~~
-
-### 2 (a)
-
-~~~~~{.ocaml}
-val getEven : int list -> int option
-~~~~~
-
-### 2 (b)
-
-
-~~~~~{.ocaml}
-let rec find_first f xs = match xs with
-  | []     -> None
-  | x::xs' -> if f x then Some x else find_first f xs'
-~~~~~
-
-### 2 (c)
-
-~~~~~{.ocaml}
-val tree_to_string: string tree -> string
-~~~~~
-
-### 2 (d)
-
-~~~~~{.ocaml}
-let rec post_fold f b t = match t with
-  | Leaf           -> b
-  | Node (x, l, r) -> f x (post_fold f b l) (post_fold f b r)
-~~~~~
-
-### 2 (e)
-
-~~~~~{.ocaml}
-let rec in_fold f b t = match t with
-  | Leaf           -> b
-  | Node (x, l, r) -> let bl = in_fold f b l  in
-                      let bx = f bl x         in
-                      let br = in_fold f bx r in
-                      br
-~~~~~
-
-
-### 3 (a)
-
-~~~~~{.ocaml}
-Left 3
-~~~~~
-
-### 3 (b)
-
-~~~~~{.ocaml}
-Right "monkey"
-~~~~~
-
-
-### 3 (c)
-
-~~~~~{.ocaml}
-let rec assoc key kvs = match kvs with
-  | (k, v)::rest -> if key = k then Right v else assoc key rest
-  | []           -> Left key
-~~~~~
-
-### 3 (d)
-
-~~~~~{.ocaml}
-let map f e = match e with
-  | Left l -> Left l
-  | Right r -> Right (f r)
-~~~~~
-
-### 3 (e)
-
-~~~~~{.ocaml}
-let map2 f e1 e2 = match (e1, e2) with
-  | Right r1, Right r2 -> Right (f r1 r2)
-  | Left l, _  -> Left l
-  | _, Left l  -> Left l
-~~~~~
-
-
-### 4 (a)
-
-~~~~~{.ocaml}
-let lookup x env = match assoc x env with
-  | Left z  -> Left (UnboundVariable z)
-  | Right i -> Right i
-~~~~~
-
-### 4 (b)
-
-~~~~~{.ocaml}
-let safeDiv n m =
-  if m != 0 then Right (n / m) else Left DivideByZero
-~~~~~
-
-### 4 (c)
-
-~~~~~{.ocaml}
-let rec eval env e = match e with
-  | Const i            -> Right i
-  | Var v              -> lookup v env
-  | Bin (e1, Plus, e2) -> map2 (+) (eval env e1) (eval env e2)
-  | Bin (e1, Div, e2)  -> (match (eval env e1) (eval env e2) with
-                           | _, Right 0 -> Left DivideByZero
-                           | Right i1, Right i2 -> Right (i1/ i2)
-                           | Left l, _ | _, Left l -> Left l)
-~~~~~
diff --git a/lectures/piazza.md b/lectures/piazza.md
deleted file mode 100644
index 7a66a47..0000000
--- a/lectures/piazza.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Piazza Discussions
-headerImg: sea.jpg
-date: 2017-03-28
----
-
-## Lambda Calculus 4/7
-
-- https://piazza.com/class/j0va76qxb1s6gw?cid=26
-- https://piazza.com/class/j0va76qxb1s6gw?cid=19
-
-
-## 4/10 
-
-- https://piazza.com/class/j0va76qxb1s6gw?cid=56
-- https://piazza.com/class/j0va76qxb1s6gw?cid=79
-
diff --git a/lectures/prolog.md b/lectures/prolog.md
deleted file mode 100644
index 8d13394..0000000
--- a/lectures/prolog.md
+++ /dev/null
@@ -1,1562 +0,0 @@
----
-title: Logic Programming
-headerImg: sea.jpg
----
-
-# Logic Programming
-
-(adapted from lecture notes by Henri Casanova and Todd Millstein)
-
-
-## Introduction
-
-
-We now turn to a brand new paradigm, called "Logic Programming Languages"
--- our vehicle for studying this paradigm is Prolog, whose roots are
-in logic and on automated theorem proving.
-Prolog was developed in the 1970s for AI applications. Some such applications
-have a knowledge base (or database) of facts, from which you'd like to
-ask queries and deduce other facts.  For example, given facts in the
-knowledge base like "Carnitas is Mexican" and "Mexican food is delicious",
-then we can deduce "Carnitas is delicious".
-
-Prolog probably looks nothing like any language you've seen before.
-Fundamental difference between Prolog and most other languages:
-
-      You don't run a Prolog Program
-
-Instead, you ask questions and the system attempts to answer them using the
-rules and facts that it has been given.
-
-      Logic programs are "declarative": the specification of the
-      desired results are written, rather than how to obtain them.
-
-This approach is very good at expressing problems that involve searching
-a large space of possibilities.  For example, given a list of cities and
-distances between them, find me the shortest route that passes through
-each one once (the travelling salesman problem).
-
-The philosophy of this approach is that it is often hard to specify a
-search algorithm -- and in such cases, it is easier to specify
-the characteristics of the solution.
-To do so, you specify *facts* and *rules* for deducing new
-facts from old facts, and then a *query*.  So you just state what is
-true and then ask what (else) is true.  The language implementation figures
-out how to actually compute appropriate solutions.
-Use the travelling salesman problem as an illustration:  I say
-the constraints, not how to search the space of possible solutions.
-Of course, as we will see, this is a simplification, and often for reasons
-of efficiency, one has to impose constraints on the search.
-
-The original and principal applications for Prolog are in various AI
-settings such as (expert databases). Examples include using prolog-based
-databases to determine when credit card fraud has occurred (prolog is used
-to specify rules that indicate when a fraud occurs), and there are
-projects afoot to use ideas from prolog to determine suspicious
-people from phone/communication patterns.
-Note that currently AI researchers devise statistical techniques to
-complement (if not replace) logical approaches for such tasks.
-Another big application is as a database query language.  
-E.g., my facts are things like the daily stock prices of various
-stocks over the last year.  Queries can be things like: find me all
-pairs of stocks that had the same price on the same day at least 50
-times this year.  
-Standard query languages like SQL are inspired by and are really subsets of Prolog.
-Of course, the reason we're studying it is that its a radically different
-way of thinking about computation: "programming as proving".
-You'll be surprised at how many places this paradigm fits beautifully, or
-leads to very elegant and readable systems.
-
-## Terms
-
-
-Based on propositional logic. The entire program comprises three kinds of
-elements: facts, rules, and queries. The basic unit of each of these are
-terms.
-
-Terms are Prolog's way of encoding data. They are very similar to the
-values of datatypes created in ML. There are three kinds of terms:
-constants, variables and compound terms.
-
-1. **Constants**: The simplest kind of terms are constants.
-
-  - _integers_ and _reals_: are constants.
-
-  - _atoms_: are identifiers starting with a lowercase letter.
-
-    For example:
-
-    `alice`, `bob`, `charlie`  
-
-    are all atoms.
-
-    **Atoms are NOT variables** -- the way to think of them is as TAGS,
-    or special constants, or elements of a giant enum datatype.
-    They are similar to the tags used in ML datatypes:
-
-~~~~~{.ocaml}
-    type day = Alice | Bob | Charlie ...
-~~~~~
-
-    Only in ML, the tags start with a capital letter.
-
-    Atoms are *uninterpreted constants*:  nothing is known about each tag
-    except that it is equal to itself.
-
-    Intuitively, Prolog knows that:
-
-    `alice = alice`
-
-    as the tags are the same. However, to it,
-
-    `alice = bob`
-
-    *never* makes sense, as it has a strange notion of equality, that we
-    will see shortly.
-
-    There are some built-in atoms such as `[]` that signifies the empty
-    list, `.` which is used for list concatenation and so on, that we will
-    see shortly.
-
-2. **Variables**: Any identifier beginning with an upper case letter
-  or an underscore is a variable.
-
-   For example,
-
-   `X`, `Y`, `Head`, `Tail`, `Alfred`
-
-   are all variables.
-
-   The variable `_` is like a **wildcard" variable**, whose meaning
-   is similar to the `_` in ML, but more on that when we see what a
-   variable means.
-
-   As we shall see:
-
-     --  `x = a` is nonsense (as x and a are two *different* constants/tags).
-     --  `X = a` has some sense (but isnt at all what one might think...).
-
-   WARNING: Upercase/Lowercase is a common source of error! Also, variables
-   are NOT declared before use (so be careful!).
-
-3. **Compound Terms**: These are terms of the form: atom(term,term,term,...)
-   where each "term" is either an atom or a variable or a compound term.
-   Examples include:
-
-~~~~~{.prolog}
-      x(y,z)
-      parent(alice,bob).   %here alice,bob are atoms
-      parent(alice,Child). %here alice is an atom, Child is a variable
-~~~~~
-
-   In other words, (compound) terms are generated by the following grammar:
-
-~~~~~{.prolog}
-	atom := [a-z][A-z,a-z,0-9]* | [0-9]* | ...
-
-	variable := [A-Z][a-z,A-Z,0-9]* | _
-
-	term := atom | variable | atom(term,term,term,...)
-~~~~~
-
-   While you may be tempted to think of compound terms like:
-
-   `parent(alice, bob)`
-
-   as function calls, they are NOT! Instead, you should think about this
-   in the same way as we thought of ML the recursive, one-of types in ML.
-
-~~~~~{.ocaml}
-   type term =   alice | bob | charlie | ... (* other atoms *)
-             | Var of string
-	           | Parent of term * term
-~~~~~
-
-   Thus, `parent(alice, bob)` in Prolog is "equivalent to" the ML value:
-
-   `Parent(alice, bob)`
-
-   which is just a tuple `alice, bob` with a tag `Parent` on it, or
-   equivalently represented as a tree:
-
-~~~~~
-          Parent
-			     /  \
-			    /    \
-			  alice  bob
-~~~~~
-
-   and parent(alice,Charlie) in Prolog is "equivalent to" the ML value:
-   Parent(alice,Var ("Charlie")), or represented as a tree:
-
-~~~~~
-			    Parent
-			     /  \
-			    /    \
-			  alice  Var
-				  |
-				  |
-				Charlie
-~~~~~
-
-
-Consider a term: `factorial(5)`
-
-It is **NOT a function** (despite what it looks like).
-
-  - there is no associated function implementation
-
-Prolog has no idea of the meaning you intend for this term -- to it,
-this is just a box containing `5` with a label `factorial`.
-
-Another way to view it is as a tree:
-
-~~~~~
-			factorial
-			    |
-			    |
-			    5
-~~~~~
-
-Thus, the only thing Prolog knows is that:
-
-`factorial(5)=factorial(5)`
-
-
-i.e. the two terms are the same. In particular, to Prolog,
-`factorial(5)=120` is NOT true.
-
-Thus Prolog compound terms are really just structured data -- like values
-of a datatype in ML. Can also think of atoms that begin a compound term
-as *uninterpreted functions*: e.g., `factorial` is a function about which
-NOTHING is known, except that the result of applying this function to the
-atom x, is the term `factorial(x)`.
-
-These atoms are called **function symbols**.
-
-## Facts
-
-A fact is just a term, typically without any variables.
-You specify a fact by writing a term followed by a '.'.
-For example, here are a few facts that one might have
-in the system.
-
-~~~~~{.prolog}
-% List of parent relationships
-parent(kim,holly).  
-parent(margaret,kim).  
-parent(herbert,margaret).
-parent(john,kim).
-parent(felix,john).  
-parent(albert,felix).
-~~~~~
-
-Note that `kim`, `holly`, `margaret`, `herbert`, `john`, `kim`, `felix`, `albert`
-are all atoms.
-
-The Prolog interpreter maintains a collection of facts like the above --
-think of it as the underlying data in the database over which queries will be asked.  
-You can define your own facts and add them to the database.  The function
-symbols beginning a fact are called *predicates*:  intuitively, they
-represent functions that evaluate to a boolean.
-
-Thus, (the atom) `parent` is a predicate that, intuitively,
-takes two arguements and returns a boolean -- we say that
-`parent` is a predicate of arity 2.
-
-The key thing to note, is that predicates have _no intrinsic meaning_.
-However, they are generally designed and named so that
-the programmer can easily "interpret" them.
-
-For example, as a programmer, I will decide that
-
-~~~~~{.prolog}
-parent(X,Y)
-~~~~~
-
-means that `X` is a parent of `Y`. In other words,
-I will specify the fact:
-
-~~~~~{.prolog}
-parent(a,b).
-~~~~~
-
-only if the person corresponding to atom `a` is
-a parent of the person corresponding to atom `b`.
-Thus, the predicate is interpreted as a logical
-relation between `X` and `Y`.
-
-Prolog uses these facts to answer queries, as well
-as to infer new facts.
-
-Lets see how it does the first.
-
-## Running Prolog : Queries  
-
-HEREHEREHEREHERE
-
-The standard interface to Prolog is in an interactive shell.
-To run it, first, lets put a bunch of facts into a file, and then load the
-file into the shell. Suppose the list of facts are stored in a file called
-"facts.pl". First, we load prolog, and get the shell prompt:
-
-Prolog prompt:   "?-"
-
-At this prompt, enter something like:
-
-?- consult('facts.prolog').     
-
-You can manually add the facts one by one by typing at the prompt:
-
-?- assert(parent(margaret,kim)).
-
-(or whatever fact you want to insert).
-
-Once this is done, the facts have been registered into the shell, we can query Prolog as follows:
-
-    1. Prompts you to type a query
-    2. You type a query
-    3. Prolog tries to prove your query
-    4. Prints out the result (or 'failure')
-    5. Repeat
-
-The simplest query is a term followed by a '.'
-(looks like a fact, but is just typed at the prompt).
-For example, suppose you type the following query:
-
-?- parent(margaret, john).  
-
-The meaning of a query is "is this fact in your database or can it be
-inferred from your database". In other words, we are asking Prolog if it
-can PROVE the fact. Prolog replies:
-
-No
-
-as this is not one of the facts (we have not yet given it any rules to
-infer new facts).
-Instead, if we were to ask:
-
-?- parent(margaret,kim).
-
-Prolog replies:
-
-Yes
-
-As this is in the database of facts we fed in.
-(Tip: If you forget the period then you can type it on the next line)
-Not bad, but not especially exciting -- we gave it a bunch of facts, and
-basically each query is effectively asking if the query term was one of the
-facts we supplied.
-
-Things get more fun, when we toss variables into the queries.
-
-      ?- parent(margaret,X).
-
-This is where we Prolog departs radically from other paradigms. The meaning
-of this query is:
-
-"What value(s) can you plug in for X such that the fact becomes provable for that value ?"
-Prolog replies:
-
-      X = kim 	[press enter if you're satisfied]
-	Yes
-
-This means that it can plug in "kim" for X, and thus, it can deduce the
-fact: parent(margaret,kim). Instead, you can enter the query:
-
-      ?- parent(X,kim).
-
-This asks prolog, for what values of X does the fact parent( _ , kim) hold.
-In other words, this innocent query is asking prolog -- who are the (known)
-parents of kim ? It replies:
-
-	X = margaret   ;	[press ';' if you want another answer]
-        X = john  ;
-	No
-
-Thus, it returns, one-by-one, all the "solutions" for X that make the fact
-parent(X,kim) provable. We can make both the parameters variables:
-
-      ?- parent(X,Y).  
-
-This asks prolog -- what are the pairs X,Y such that X is (provably) the
-parent of Y ? It responds:
-
-	X=kim  Y=holly ;
-	X=margaret  Y=kim;
-	...
-
-Suppose you want to know if there are any strange circularities in your
-fact database -- for example, does there exist any person who is their own
-parent ? The following query does the trick:
-
-      ?- parent(X,X).  
-      	No
-
-------------------------------- Unification -----------------------------------
-
-In most other languages, a function designed to look up
-things like this would be less flexible -- it would require tedious
-parentOf() method or a childOf() method, loops, etc.
-With Prolog -- the queries are very flexible, and work like magic.
-Whats going on ?
-
-Turns out that Prolog's computational heart is a fancy pattern matching
-technique (also, btw, at the heart of ML's type system) borrowed from
-logicians,  called "Unification". Regrettably, we won't have time to go
-into the details of unification -- and so, lets content ourselves with a
-cartoon version.
-
-
-	Intuitively, two terms can be unified   if there a
-	way of assigning values to their variables so that
-	the terms become identical.
-
-This is really what " = " means in prolog -- when you ask it:
-
-	?-  t1 = t2.
-
-For any two terms t1 and t2, you are asking it whether the terms t1 and t2
-can be unified. So, if you ask:
-
-   ?- foo(bar) = foo(bar).
-      Yes
-
-Because there are no variables and the terms are the same.
-If instead you ask:
-
-   ?- foo(X) = foo(bar).
-
-It replies:
-      X = bar
-      Yes
-
-Meaning that foo(X) can be unified with foo(bar) by assigning the variable
-X to the term "bar".
-Note that we can ask this from Prolog without "declaring" any of the above
-atoms. This is because everything is symbolic -- everything is a term which
-is an arbitrary  notation that can encode whatever concept.
-One can type the above right after starting the interpreter.
-
-
-The more interesting case is when there are several variable in the terms:
-
-   ?- p(X,dog) = p(cat,Y).
-      X = cat
-      Y = dog
-      Yes
-
-meaning that one can unify the terms p(X,dog) and p(cat,Y) by assigning
-appropriate values to X and Y. However, if we were to ask:
-
-   ?- p(cat) = p(dog).
-      No
-
-As the terms are different, and so, if we ask:
-   ?- q(X,dog,X) = p(cat,Y,Y).
-      No
-
-is the answer as to unify, X must be "cat" and Y must be "dog", but this
-ensures that the last parameter of the term can never be the same!
-
-Similarly, the unification happens "deep" into the terms:
-
-?- a(W,foo(W,Y),Y) = a(2,foo(X,3),Z).
-      W = 2
-      X = 2
-      Y = 3
-      Z = 3
-      Yes
-
-Intuitively, it first matches up the first position, and so W gets 2,
-next, it tries to match up the second position -- i.e.
-
-	foo(W,Y) with foo(X,3).
-
-now, W is already 2, so X also gets 2, and Y gets 3.
-Finally, it tries to match up the last position,
-and Y is 3 and so Z gets 3.
-
-Instead, the query:
-
-?- a(W,foo(W,Y),Y) = a(2,foo(X,3),X).
-   No
-
-Thus, by using W,X,Y in two places, we are forcing it to find a solution where
-those two places get exactly the same value. As a result, the constraints
-ensure that all the variables must get the same value. However, W and Y
-must get 2 and 3 and so there is no solution.
-
-Thus, this innocent "pattern matching" operation actually does a lot under
-its hood, and it turns out to be a surprisingly powerful and flexible way
-to encode all kinds of computation! All the queries that we asked before,
-were answered via unification.
-
-When we ask:
-
-	?- parent(margaret, john).  
-
-prolog checks if the term "parent(margaret,john)" can be unified with any
-of the known facts (that are also terms). If so, it says Yes, but as it
-cannot, it replies No.
-
-When we ask:
-
-	?- parent(margaret,kim).
-
-it can unify the query term with a known fact term, and so it replies Yes.
-
-When we ask:
-
-	?- parent(margaret,X).
-
-it tries to find all the known facts with which it can unify the query term
--- there is only one, and so it "answers the query" by returning the
-substitution required for unification:
-	X = kim
-
-Similarly, when we ask:
-
-      ?- parent(X,kim).
-
-It attempts to find all the known terms with which this query can be
-unified -- this time, there are several terms, and the different
-valid unifying substitutions (called unifiers) yield the different parents
-of kim:
-	X = margaret   ;
-        X = john  ;
-	No
-
-Finally, to answer the query:
-
-	?- parent(X,Y).
-
-It attempts to unify the query term with all known facts -- and the list of
-resulting unifiers is exactly the set of known parent child pairs.
-
-------------------------------- Conjunction ------------------------------
-
-Often, its more useful to ask questions about several terms.
-For example, to determine if margaret is holly's grandparent, we would like
-to find if there is some person who is both the child of margaret AND the
-parent of holly.
-To do so, we can issue a conjunctive query which is a list of terms
-separated by commas as follows:
-
-      ?- parent(margaret, X), parent(X, holly).
-
-To answer this query, Prolog attempts to find an X such that
-parent(margaret,X) unifies with the set of known facts, AND,
-parent(X,holly) unifies with the set of known facts.
-Upon finding a unifier that works, it replies:
-
-	X = kim
-	Yes
-
-Thus, as kim is the intermediate parent, we can conclude that margaret is
-indeed a grandparent of holly. Finally, consider the following query:
-
-      ?- parent(X,Y), parent(Y,Z), parent(Z,kim).
-
-It asks if there are X,Y,Z such that X is Y's parent, Y is Z's parent and Z
-is kim's parent. In other words, the query determines if kim has any
-"great-grandparent". Upon finding appropriate unifiers, prolog replies:
-
-	X = john
-	Y = felix
-	Z = albert
-	Yes
-
-------------------------------- Rules ------------------------------------
-
-The above is quite nifty -- it allows us to quickly mine the database to
-find interesting relationships. However, it gets somewhat cumbersome as we
-have to devise a complex conjunctive query ever time.
-Instead, it would be nice if we could define complex queries out of simpler
-queries.
-
-Rules serve exactly that purpose. They allow us to specify complex queries
-(i.e. predicates) using simpler ones. In general, the format of a rule is:
-
-     head :- condition1, condition2, condition3....
-
-Intuitively, it means, that the "head" query is true if condition1,
-condition2, condition3,... are all true. In other words, it tells prolog,
-to prove the head query, prove the conditions 1,2,3.
-
-For example, suppose we'd like to define a grandparent relationship
-(predicate). We do so as:
-
-    grandparent(GP,GC) :- parent(GP,P), parent (P,GC).
-
-Intuitively this states:
-
-   "GP is a grandparent of GC if GP is a parent of P AND P is a parent of GC".
-
-With this definition, we can now issue the following query:
-
-      ?- grandparent(X,kim).
-
-and prolog responds with:
-
-	X=herbert
-	Yes
-
-as it can find that parent(herbert,margaret) and parent(margaret,kim),
-therefore, applying the rule, grandparent(herbert,kim), to which fact the
-query term gets unified. We can use this predicate to write more
-predicates:
-
-    greatgrandparent(GGP,GGC) :- parent(GGP,GP) , grandparent (GP, GGC).
-
-We can now issue the query:
-
-    ?- greatgrandparent(X,holly).
-       X=herbert
-       Yes
-
-Program = Facts + Rules:
-------------------------
-
-Facts and Rules are the two kinds of "Clauses" (intuitively, a fact is
-just a rule without any conditions).
-Thus, a prolog program is a set of clauses -- partitioned into a
-database of facts and a set of rules for inferring new facts.
-
-Scope:
-------
-Notice that the same variable P appears twice in the grandparent rule.
-Indeed one may be tempted to reuse P across several rules. In Prolog, the
-scope of a variable is the clause (rule) that contains it. Thus, there is
-no connection whatsoever between variables across clauses.
-
-For example, consider the two clauses:
-
-       foo(P) :- bar(P).        % There is no connection between P in
-       stuff(P) :- thing(P).    % the 2 clauses.
-
-In other words, there are no global variables, all variables are local to
-the individual clauses.
-
------------- Multiple Clauses =  Disjunction and Recursion ---------------
-
-Suppose we want to define a predicate that is true for all those persons
-that have some family -- that is, those persons who have either a parent OR
-a child. We can do so as follows:
-
-	has_family(X) :- parent(X,_).
-	has_family(X) :- parent(_,X).
-
-If we have multiple rules for the same predicate, effectively we are
-specifying a disjunction. The first rule says:
-
-   "X has a family if there is some _ such that X is the parent of _"
-
-The second rule says:
-
-   "X has a family if there is some _ such that _ is the parent of X"
-
-If either of these clauses fire then, has_family(X) becomes true.
-Like in ML, the symbol "_" represents a "wildcard" or dont-care
-variable that we will use only in one place and so we not bother
-to name it.
-
-Thus,
-   ?- has_family(holly).
-   Yes
-
-as the second rule fires for holly. While,
-
-   ?- has_family(mugatu).
-   No
-
-as neither rule fires for mugatu.
-
-For those of you who are economical with the keystrokes, there is another
-way to specify disjunctive rules -- via a semicolon:
-
-   has_family(X) :- parent(X,_) ; parent(_,X).
-
-
-Suppose you want to specify an predicate ancestor(X,Y) which is true if
-X is an ancestor of Y, i.e. if by following the parent relationship from Y
-one eventually reaches X. Intuitively, X is an ancestor of Y either if:
-
-	1. X is the parent of Y, or,
-	2. Z is the parent of Y, and X is an ancestor of Z.
-
-Thus, we can specify this predicate recursively as follows:
-
-    ancestor(X,Y) :- parent(X,Y).                %[Base case]
-    ancestor(X,Y) :- parent(Z,Y),ancestor(X,Z)   %[Recursive case]
-
-This works quite niftily:
-
-    ?- ancestor(kim,X).
-       X = holly ;
-       No
-
-i.e. holly is the only "descendant" of kim, and:
-
-    ?- ancestor(X,kim).
-       X = margaret ;
-       X = john ;
-       X = herbert ;
-       X = felix ;
-       X = albert ;
-       No
-
-i.e. kim has a long ancestry.
-
------------------------------ Backtracking Search ---------------------------
-
-At this point, its worth looking into how exactly prolog pulls off this
-trick of answering queries in this manner, as it has its limits, which one
-needs to know to phrase the queries appropriately. Turns out, there's no
-real magic -- just brute force "proof" search.
-
-We can view each clause as a "proof rule":
-
-      goal :- subgoal_1, subgoal_2,...
-
-Thus, the rules for ancestor are as follows:
-
-ancestor(X,Y) :- parent(X,Y).			%rule 1
-ancestor(X,Y) :- parent(Z,Y),ancestor(X,Z).	%rule 2
-
-To prolog, these rules mean the following -- to prove ancestor(X,Y), try to:
-
-  1. prove the subgoal parent(X,Y), or, failing that,
-  2. prove the subgoal parent(X,Z), and then the subgoal ancestor(X,Z).
-
-Thus, suppose we ask it the query:
-
-  ?- ancestor(felix,holly).
-
-To prove this query, it undertakes the following backtracking search:
-
-
-		ancestor(felix,holly)?
-		  /		                \
-  parent(felix,holly)    parent(Z,holly)
-	  NO		               ancestor(felix,Z)
-				|
-				| Z = kim  (by fact)
-				|
-			  ancestor(felix,kim)
-			  /                \
-	  parent(felix,kim)     parent(Z',kim)
-	      NO                ancestor(felix,Z')  ----------|
-			                     |                            | Z'=john
-		           Z'=margaret |                            |
-				          |                             ancestor(felix,john)
-		      ancestor(felix,margaret)                      |
-		              /        \                      parent(felix,john)
-	parent(felix,margaret)   parent(Z'',margaret)         YES
-		          NO           ancestor(felix,Z'')
-                                      |
-		                    Z'' = herbert |
-		                                  |
-			                  ancestor(felix, herbert)
-			                 /              |
-		 parent(felix,herbert)   parent(Z''',herbert)
-		            NO			             NO
-
-Thus, it first tries the base rule i.e. to prove the subgoal parent(felix,holly).
-As it cannot unify this query with any known fact, it fails (NO),
-and so it backtracks and tries the other recursive rule.
-The only Z such that parent(Z,holly) unifies with a known fact is when
-Z=kim, thus, it tries to prove the second subgoal ancestor(felix,kim).
-To do so, again it first applies the base rule, which fails, and so it
-backtracks and applies the recursive rule.
-
-This time, there are two different Z (written Z' in the figure to
-distinguish from the upper part of the tree), such that parent(Z,kim) --
-namely Z=margaret and Z=john. It picks margaret first (as that is the first
-unification that succeeds, and tries to prove the the second subgoal
-ancestor(felix,margaret). As we can see, from the subtree, this search
-fails, (as margaret's sole parent is herbert who has no parent).
-
-Thus, prolog backtracks and tries the second Z=john, and tries to prove the
-second subgoal, ancestor(felix,john). This time, the base rule works as
-parent(felix,john) is a known fact, and thus the proof search succeeds and
-prolog returns:
-
-  ?- ancestor(felix,holly).
-     Yes
-
-This same process is repeated for any query. When there is a variable in
-the query, eg.
-
-  ?- ancestor(X,kim).
-
-Prolog attempts the proof search and returns all the unifiers for X for which
-the proof succeeds. Thus, prolog is literally programming by proving.
-
-
-Hint: Trace mode in prolog shows the tree:
-
-    ?- trace.
-
-The subsequent query is traced: use the on-line help on the ACS Prolog interpreter
-
-    ?- help(trace).
-
-Order Matters:
---------------
-
-The rub is that the order of the clauses and terms influences greatly the order
-in which the unification and backtracking happens. This is because, to
-prove a particular goal query, the different clauses are selected in
-order, and further, within each clause, the subgoals are selected from
-left-to-right, which affects how the unification happens.
-
-In the above example, if we had entered the branch Z'=john rather than
-than the branch Z'=margaret, then we would have proven the query faster.
-Similarly, if we had swapped the order of the conjunctions (subgoals) in
-the recursive clause, we would have a rather different tree (try as an
-exercise). Thus, order matters for performance.
-Hint: Try simple things first!  
-
-More importantly, there are cases where the program may not even work (may
-not terminate), depending on the order:
-
-    ancestor(X,Y) :- ancestor(X,Z), parent(Z,Y).
-    ancestor(X,Y) :- parent(X,Y).
-
-Now lets try the same query:
-
-    ?- ancestor(felix,holly).
-     ERROR: Out of local stack
-
-Why ? Well, if you try to build the search tree, you'll see it goes forever:
-
-		ancestor(felix,holly)?
-		  |
-			|
-			|
-		ancestor(felix,Z)  %prove first subgoal,
-			|          %then parent(Z,holly)
-			|
-			|
-		ancestor(felix,Z') %prove first subgoal,
-			|	   %then parent(Z',Z)
-			|
-			|
-		ancestor(felix,Z'')
-			.
-			.
-			.
-
-So, to avoid this, we must place the parent subgoal first (in the recursive
-rule). If this is done, the unification with the base facts (parent),
-fix the possible unifiers for Z, thereby guaranteeing termination.
-
-HEREHEREHEREHERE
-
-Lets see another example. Suppose we want to define a sibling predicate,
-where sibling(X,Y) holds if X and Y have the same parent. How about:
-
-    sibling(X,Y) :- parent(P,X), parent(P,Y).
-
-Almost:
-
-    ? sibling(kim,kim).
-    Yes
-
-Ah, we have to ensure that X and Y are not the same. Ok, how about:
-
-    sibling(X,Y) :- not(X=Y), parent(P,X), parent(P,Y).
-
-Surely this works ? Nope. The reason is prolog's semantics of equality
-(i.e. unification). This clause is read by prolog as:
-
-first, find a X,Y such that X cannot be unified with Y,
-then, find a P such that parent(P,X), and parent(P,Y).
-
-Now the catch is that to process the first subgoal, prolog finds it can
-always unify (two unconstrained variables) X and Y, by simply assigning X to Y!
-	?- X=Y.
-	X=Y
-	Yes
-
-	?- not(X=Y).
-	No
-
-Thus, the very first subgoal always fails, thereby ensuring that:
-
-	?- sibling(X,Y).
-	No
-
-Thus, to get the rule right, we must make sure that the goal that ensures
-that X and Y are not the same, is fired AFTER X and Y have been unified
-with appropriate atoms. We can do so by simply placing the subgoal at the
-end.
-    sibling(X,Y) :- parent(P,X), parent(P,Y), not(X=Y).
-
-    ?- sibling(X,Y).
-    X = john
-    Y = maya ;
-
-    X = felix
-    Y = dana ;
-
-    X = dana
-    Y = felix ;
-
-    X = maya
-    Y = john ;
-    No
-
-This shows a major weakness: You can's just rely on the logical
-meanings and you sort of need to know how things work.
-
-Oh well, nothing's perfect.
-
-We'll see that many, many things break down the pure philosophy
-that says: "Just write what you need logically"
-
----------------------------- Numeric Computation --------------------------
-
-Although Prolog is mostly symbolic, there is a need for numeric
-computation.
-
-  - '=' is the unification operator
-	?- X = 2+3.
-	    X = 2+3
-	    Yes
-  - 'is' evaluates arithmetic expressions before doing unification
-	?- X is 2+3.
-	    X = 5
-	    Yes
-
-When prolog tries to solve an "is" goal it evaluates the second argument
-and then unifies, as opposed to "=" which just does the unification.
-
-	?- Y is X+2, X=1.
- 	ERROR: Args are not sufficiently instantiated
-
-	?- X=1, Y is X+2.
-          X=1
-          Y=3
-          Yes
-
-Again, order of evaluation matters!
-
-Functions are Predicates:
--------------------------
-
-Lets try to write a factorial function in Prolog. We need to somehow encode
-functions as predicates. Here's the deal:
-Whenever you have a function f(x), you can write a predicate
-
-	pred_f(X,Y)
-
-that captures the behavior of f by being true for all those pairs X,Y
-where Y is f(X).
-
-Thus, we can write a predicate capturing the input/output relationship of
-the factorial function -- i.e. a predicate factorial(X,Y), that is true for
-those pairs X,Y where Y is the factorial of X.
-
-	factorial(0,1). % base case
-	factorial(X,N):- X1 is X-1, factorial(X1,N1), N is X1*N1.
-
-We "call" the function with a query.
-
-	?- factorial(0,X).
-	X = 1
-	Yes
-
-	?- factorial(5,X).
-	X = 120
-
-
----------------------------- Data Structures: Lists --------------------------------
-
-Let us now see how we can encode lists in Prolog. Again, its useful to
-recall how lists were encoded as a datatype in ML.
- -- There is a "base atom": [] denoting the empty list
- -- There is a "cons"tructor: | (different syntax for this).
-
-Thus, ML's list Cons(1,Cons(2,Cons(3,Nil))) is equivalent
-to the prolog term:
-
-	[1|[2|[3|[]]]]
-
-where (1) | is Cons, and (2) [] is Nil.
-
-Also, as they are heavily used, Prolog lets you write the above term as:
-[1,2,3].
-
-	?- [1,2,3] = [1|[2|[3|[]]]].
-	Yes
-
-To "deconstruct" a list into head and tail, we use pattern-matching (very
-much like in ML). So:
-
-  [X|Y] unifies with any non-empty list (like h::t),
-  	X unified to the first element (head)
-	Y unified to the rest of the list (tail).
-
-	?- [X|Y] = [1,2,3,4,5].
-	X = 1
-	Y = [2,3,4,5]
-	Yes
-
-	?- [X|Y] = [1].
-	X = 1
-	Yes
-
-	?- [X|Y] = [].
-	No
-
-  [1|Y] unifies with any list starting with 1 (like 1::t),
-  	Y unified to the rest of the list.
-
-
-  However, prolog also lets you write:
-
-  [1,2|X] which unifies with any list that starts with 1 and then 2.
-  	?- [1,2|X] = [1,2,3,4,5].
-	   X = [3,4,5]
-	   Yes
-
-	?- [1,2|X] = [1,2]
-	   X = []
-	   Yes
-
-	?- [1,2|X] = [1,3]
-	   No
-
-	One can place variables wherever in the term, so:
-        ?- [X,Y|Z] = [1,2,3].
-           X = 1
-           Y = 2
-           Z = [3]
-
-Ok -- how do we do interesting things with lists. For example, how might we
-"append" two lists ? Well, there is no "concatenation" or sticking
-together. In prolog you write a predicate:
-
-	append(X,Y,Z)
-
-which is true if Z is the result of appending the lists X and Y.
-Turns out such a predicate is built-in, so lets see what it does.
-
-      ?- append([1,2],[3,4],Z).
-        Z=[1,2,3,4]
-	Yes
-
-It simply "solves" for the right Z that happens to be the result of
-appending [1,2] and [3,4], but wait, predicates can do more:
-
-      ?- append(X,[3,4],[1,2,3,4]).
-        X=[1,2]
-
-whoa! backwards computation -- what X is such that when appended to [3,4]
-you get [1,2,3,4] ? And now, the full power of multiple solutions:
-
-      ?- append(X,Y,[1,2,3]).
-        X = []
-        Y = [1,2,3] ;
-
-        X = [1]
-        Y = [2,3] ;
-
-        X = [1,2]
-        Y = [3] ;
-
-        X = [1,2,3]
-        Y = []
-        Yes
-
-Try doing that in another language.
-
-There are several such predicates for reverse, sort, append, built-in, but
-lets try to roll our own.
-
-  	How would you write append(X,Y,Z) in Prolog?
-
-Well, the base case is that if X is empty then, Z is just Y.
-
-      append([], Y, Y).         % base case
-
-The recursive case is when X is of the form [H|Tx], in which case, Z must
-begin with H, and the tail of Z is obtained by appending Tx to Y:
-
-      append([H|T], Y, [H|Tz]) :- append(Tx,Y,Tz).     % recursive case
-
-Very different way of thinking than imperative languages. Lets see what
-happens with the query:
-	 ?- append([1],[2],Z).
-
-	 Prolog tries to prove the term append([1],[2],Z)
-	 ---> recursive case fires.
-	 H unifies to 1
-	 Tx unifies to []
-	 Y unifies to [2]
-	 Z unifies to [1|Tz]
-	   ---> prove:      append(Tx,Y,Tz)
-	   ---> i.e. prove: append([], [2], Tz)
-	   base case fires.
-              ---> Tz unifies to [2]
-              ---> therefore:  Z = [1,2]
-
-But, because of the magic of pattern matching, proving and predicates, you
-get the backwards computations by the same "proving" process !
-
-Lets do a few more. Lets write a predicate tailof(X,Y) which is true if Y
-is the tail of the list X.
-
-	tailof([_|X],X).
-
-Again, note the judicious use of the wildcard "_". If you actually named
-the variable there, eg.
-
-	tailof([H|X],X).
-
-The compiler would warn you that you named a variable but used it only
-once -- a "Singleton Variable".
-
-Lets write a predicate which is true of lists with three or more elements:
-
-    has3orMoreElements([_,_,_|_]).
-
-What does this predicate do ?
-
-    foo([X,_,_,_,X|_]).
-
-One more tricky one. Lets write a predicate isin(X,L) which is true if
-X is an element of the list L. How ?
-
-base case: if X is the first element of the list L.
-
-	isin(X,[X|_]).
-
-recursive case: if X appears in the tail of the list L.
-
-	isin(X,[_|T]) :- isin(X,T).
-
-Let's give it a spin:
-
-	?- isin(2,[1,2,3]).
-	Yes
-
-	?- isin(X,[1,2]).
-	X=1 ;
-	X=2 ;
-	No
-
-	?- isin(1,[2,3]).
-	No
-
-
-Let's write another predicate:
-
-	mylength(L,X)
-
-which is true if X is the length of list L
-
-  mylength([],0).
-  mylength([_|Tail],Len) :- mylength(Tail,TailLen),
-		            Len is TailLen +1.
-
-  ?- mylength([1,2],L).
-     does not unify with  mylength([],0)
-     unifies with mylength([_|Tail],Len) with the bindings:
-            Tail = [2]  and Len = L
-
-       now I need to prove the two things:
-         mylength([2],TailLen)   and  Len is TailLen + 1
-
-         can I prove the first one?
-         mylength([2],TailLen)  does not unify with mylength([],0)
-         mylength([2],TailLen)  unifies with  mylength([_|Tail'],Len')
-               with the bindings:
-	      Tail' = []   and Len' = TailLen
-
-	    now I need to prove the two conditions:
-              mylength([],TailLen'') and Len' is TailLen'' + 1
-              can I prove the first one?
-              mylength([],TailLen'') unifies with mylength([],0)
-                 with the bindings:  TailLen'' = 0
-              Len' is TailLen'' + 1  then leads to the binding
-                 Len' = 1
-              therefore TailLen is equal to Len', and thus to 1
-            therefore Len is equal to Len' + 1, and thus to 2
-          therefore L is equal to Len, and thus to 2
-        Prolog answers L = 2.
-
------------------------------------ Cuts ----------------------------------
-
-  - Ordering clauses and goals is a way to somewhat control the search and
-    backtracking process, but it is very limited.
-  - There is something called a "cut" that prevents Prolog from backtracking.
-  - Example: Let's say we're writing a program to compute the following step function:
-        X < 3   phi(X) = 0
-   3 <= X < 6   phi(X) = 2        
-   6 <= X       phi(X) = 4
-
-  In Prolog we can implement this with a binary predicate, f(X,Y), which
-  is true if Y is the function value at point X. For instance, f(0,0) is
-  true, f(4,2) is true, but f(2,4) is false. Here is the program:
-
-       f(X,0) :- X < 3.                  [rule 1]
-       f(X,2) :- 3 =< X, X < 6.          [rule 2]     note '=<'
-       f(X,4) :- 6 =< X.                 [rule 3]
-
-  There are two sources of inefficiency in this program, that we'll see
-  on one example:
-
-     ?- f(1,Y), 2 < Y.      [find a Y such that Y = f(1)  and 2 < Y]  
-                            [ we can see this is going to fail]
-
-   what does Prolog do?
-
-                    f(1,Y)
-                    2 < Y ----------
-         rule 1  /    \             \
-         Y = 0  /      \  rule 2     \  rule 3
-               /        | Y = 2       |  Y = 4
-              |         |             |
-            1 < 3      3 <= 1        6 <= 1
-            2 < 0      1 < 6         2 < 4
-             |         2 < 2          NO
-             |         NO
-            2 < 0      
-             NO
-
-   There is really no point in trying rule 2 and rule 3 because since X < 3, we
-   know that rule 2 and rule 3 will fail. Basically, the three rules are mututally
-   exclusive. We know that. Prolog doesn't.
-
-   So, we can "cut" the backtracking by using the '!' operator:
-
-       f(X,0) :- X < 3, !.   
-       f(X,2) :- 3 <= X, X < 6, !.
-       f(X,4) :- 6 <= X.      
-
-
-   The new execution looks like:
-
-                    f(1,Y)
-                    2 < Y
-         rule 1  /    
-         Y = 0  /    
-               /    
-              |    
-            1 < 3
-            2 < 0
-             |      
-             CUT
-             |   
-            2 < 0      
-             NO
-
-    Lessons: cuts can be used to prevent Prolog from going into branches
-             of the search tree that we know, due to our understanding and
-             knowledge of the problem, will not succedd anyway.
-
-  - There are many more things possible with cuts and using them well is
-    an art. A program with no cuts at all will run orders of magnitude
-    slower than an equivalent program with a few '!' thrown in.
-
-
--------------------------- Accumulators ---------------------------
-
-  - There are cases in which you want to add an argument to a predicate
-    just to keep track of useful information
-
-Example: List Reverse:
-----------------------
-
-We will now write a predicate:
-
-	rev(X,Y)
-
-that is true if the list Y is the reverse of the list X.
-To do so, we will use an accumulator that tracks the elements seen so far
-in X.
-
-	rev(X,Y) :- acc_rev(X,Y,[]).
-
-The third parameter is the "accumulator". We will "push" elements into it
-in the order they appear in X. Thus, when we have pushed all the elements,
-the third parameter is the "reversed" version of X.
-
-	acc_rev([],Y,Y).  %base case
-	acc_rev([H|T],Y,SoFar) :- acc_rev(T,Y,[H|SoFar]). %recursive case
-
-
-	?- rev([1,2,3],Y).
-	Y = [3,2,1]
-	Yes
-
-	?- rev(X,[3,2,1]).
-	X = 1,2,3
-	Yes
-
-The nice thing about predicates, is one can go forwards or backwards! Its
-completely symmetric...
-
-
-
-
-Example: Finding all solutions:
--------------------------------
-
-Suppose we have a predicate foo(X), defined:
-
-      foo(a).  
-      foo(b).
-      foo(c).
-      foo(d).
-
-and say we want to find all the terms X such that foo(X) is true.
-We will use an accumulator to define a predicate:
-
-	allfoos(L)
-
-that is true for a list of terms iff every term in the list satisfies foo.
-
-
-      allfoos(L) :- listallfoos(L,[]).
-
-listallfoos is a helper predicate, whose second argument is an accumulator
-that "tracks" which terms satisfying foo are already known. We shall then
-"add" those terms that satisfy foo, but are not in the "accumulator".
-
-      % recursive case
-      listallfoos([X|L],SoFar) :- foo(X),    
-                                  not(isin(X,SoFar)),
-                                  append(SoFar,[X],NewSoFar),
-                                  listallfoos(L,NewSoFar).
-      % base case
-      listallfoos([],_).    
-
-      ?- allfoos(A).
-        must prove listalllfoos(A,[]).
-        unifies with listallfoos([X|L],[])
-          must prove four things: foo(X)
-                                  not(isin(X,[])
-                                  append([],[X],NewSoFar)
-                                  listallfoos(L,NewSoFar)
-            foo(a) 			true   (X is bound to a)
-            not(isin(a,[])) 		true
-            append([],[a],NewSoFar)	true with NewSoFar=[a]
-            must prove listallfoos(L,[a])
-            unifies with liastallfoos([Y|L'],[a])
-             must prove four things: foo(Y)
-                                     not(isin(Y,[a]).
-                                     append([a],[Y],NewSoFar')
-                                     listallfoos(L',NewSoFar')
-               foo(a)		  true
-               not(isin(a,[a]))   false  BACKTRACK
-               foo(b)		  true  (Y is bound to b)
-	       not(isin(b,[b]))   true
-               append([a],[b],NewSoFar')  true with NewSoFar' = [a,b]
-               must prove listallfoos(L',[a,b])
-               unifies with listallfoos([Z|L''],[a,b])
-                 must prove four things: foo(Z)
-                                         not(isin(Z,[a,b])
-                 one can see that will fail   BACKTRACK
-               unifies with listallfoos([],[a,b]).
-               therefore: L' unifies with []
-             therefore: [Y|L'] unifies with [b]
-             therefore L unifies with [b]
-             therefore [X|L] unifies with [a,b]
-           therefore A unifies with [a,b]
-         therefore  allfoos([a,b])
-
-If you try this code, and hit ';', you'll get multiple answers
-Try to figure out why (using the "trace" mode)
-Solution: add a cut
-
-      listallfoos_cut([X|L],SoFar) :-
-            foo(X),    
-            not(isin(X,SoFar)),
-            append(SoFar,[X],NewSoFar),
-            listallfoos(L,NewSoFar),!.
-
-      listallfoos_cut([],_).
-
-What happens when you flip order of base case and recursion ?
-
----------------------------- Puzzle Solving ----------------------------
-
-We now have a good feel for what Prolog programs look like. Lets finish, by
-seeing how succinctly and elegantly prolog allows us to write code to solve
-tricky logical puzzles.
-
-
-Towers of Hanoi:
----------------
-
-                  |            |           |
-                 =|=           |           |
-               ===|===         |           |
-             =====|=====       |	         |
-	         =======|=======     |           |
-       --------------------------------------------------		
-		Peg 1        Peg 2       Peg 3
-
-Puzzle: There are three pegs. On the first one, there is a stack of rings
-of decreasing radius (that forms a tower).
-In each step, you are allowed to move the top ring from one peg to another, but
-only if the rings in the new peg form a conical tower -- i.e. as long as
-the sequences of radii from top to bottom is increasing (as shown in the
-figure).
-
-  - Goal: Find the sequence of moves (move top ring from from peg X to peg Y)
-          that moves the tower from peg 1 to peg 3.
-  - The basic action is to move 1 disk, with printing
-
-	move(A,B) :-
-		nl, write ('Move topdisk from '),
-                write(A), write(' to '), write(B).
-
-  - the main predicate is transfer(N,A,B,X):
-      represents "Move N disks from peg A to peg B by using peg X as a helper"
-  - base case:
-      transfer(1,A,B,X) :- move(A,B).
-      Better written as: transfer(1,A,B,_) :- move(A,B).
-
-  - inductive case:
-     transfer(N,A,B,X) :-
-		transfer the top N-1 disks to X
- 	        transfer the (bottom) disk from A to B
-                transfer the top N-1 disks from X to B
-
-     transfer(N,A,B,X) :-
-		M is N-1,
-		transfer(M,A,X,B),
-		move(A,B),
-		transfer(M,X,B,A).
-
-Lets see how these work -- lets name the pegs using atoms: peg1, peg2,
-peg3. Here's the sequence of moves to transfer a tower of size 3 across
-(you can try this at home!).
-
-
-  ?- transfer(3,peg1,peg3,peg2).
-    Move topdisk from peg1 to peg3
-    Move topdisk from peg1 to peg2
-    Move topdisk from peg3 to peg2
-    Move topdisk from peg1 to peg3
-    Move topdisk from peg2 to peg1
-    Move topdisk from peg2 to peg3
-    Move topdisk from peg1 to peg3
-
-
-
-
-Farmer/ Wolf / Goat / Cabbage:
-------------------------------
-
-	 *West*              *East*
-
-       Goat       |       |           Goat eats cabbage if no farmer
-       Wolf       | river |           Wolf eats goat if no farmer
-       Cabbage    |       |           Only one spot on the boat(farmer+1)
-
-Configure the "state" of the program as a list with the location of the
-four objects (farmer, wolf, goat, cabbage). There are two locations: West (w)
-and East (e).
-
-       initial state:        [w,w,w,w]
-
-       desired state:        [e,e,e,e]
-
-There are four kinds of moves:
-	with the cabbage, (move_cabbage)
-	with the goat,    (move_goat)
-	with the wolf,    (move_wolf)
-	with nothing.     (move_nothing)
-
-Here is how the "state" changes with a given move:
-
-For instance,   [w,w,w,w] ---"move wolf"--> [e,e,w,w]
-
-We encode this as:
-
-       move([w,w,w,w],move_wolf,[e,e,w,w]).
-
-          (this just says that the state transformation above is true)
-
-We could write all the possible moves as facts, but there would be a lot. However,
-it is clear that when the farmer and wolf move, the goat and the cabbage do not
-move, so a more general fact is:
-
-       move([w,w,P_Goat,P_Cabbage],move_wolf,[e,e,P_Goat,P_Cabbage]).
-       move([e,e,P_Goat,P_Cabbage],move_wolf,[w,w,P_Goat,P_Cabbage]).
-
-therefore, a more general goal is:
-
-       move([X,X,P_Goat,P_Cabbage],move_wolf,[Y,Y,P_Goat,P_Cabbage]) :- change(X,Y)
-
-where we have:
-                 change(e,w).
-                 change(w,e).     
-
-In addition to ensuring that X and Y are different, this predicate ensures
-that they cannot be any random atom -- they must be either "e" or "w".
-
-Now we can just write the whole program:
-
-       move([X,X,P_Goat,P_Cabbage],move_wolf,[Y,Y,P_Goat,P_Cabbage]) :- change(X,Y).
-       move([X,P_Wolf,X,P_Cabbage],move_goat,[Y,P_Wolf,Y,P_Cabbage]) :- change(X,Y).
-       move([X,P_Wolf,P_Goat,X],move_cabbage,[Y,P_Wolf,P_Goat,Y]) :- change(X,Y).
-       move([X,P_Wolf,P_Goat,P_Cabbage],move_nothing,[Y,P_Wolf,P_Goat,P_Cabbage]) :- change(X,Y).
-
-At this point we have encoded all the possible moves. But there is nothing about
-moves being safe or unsafe.  We need a safe predicate that takes a state as input and
-is true if the state is sage (nobody eats nobody).
-
-  "if at least one of the goat or the wolf is on the same bank as the farmer, AND
-      at least one of the goat or cabbage is on the same bank as the farmer,
-   then we're safe"
-
-We define the one_equal(X,Y,Z) predicate that returns true if at least one
-of Y or Z is equal to X:
-
-    one_equal(X,X,_).
-    one_equal(X,_,X).
-
-then we can have:
-
-     safe([P_Farmer,P_Wolf,P_Goat,P_Cabbage]) :-
-         one_equal(P_Farmer,P_Goat,P_Wolf),
-	 one_equal(P_Farmer,P_Goat,P_Cabbage).
-
-this encodes the logical statement we made above.
-
-A solution is defined as a sequence of moves such that we are either:
--- in the target configuration, all on the east bank, or,
--- in a state from which there is a single move, which takes us into
-a safe state, from which we can get to the target configuration.
-
-    solution([e,e,e,e],[]).
-    solution(State,[FirstMove|RemainingMoves]) :-
-       move(State,FirstMove,NextState),
-       safe(NextState),
-       solution(NextState,RemainingMoves).
-
-The program is complete.
-
-Example run:
-
-If you just type solution([w,w,w,w],X), we get into an infinite loop as there are
-infinitely solutions. So:
-
-    ?- length(X,7), solution([w,w,w,w],X).
-
-     X = [goat, nothing, wolf, goat, cabbage, nothing, goat]
-
-In fact, 7 steps is the shortest solution.
-
-    ?- length(X,12), solution([w,w,w,w],X).         (needs an odd number of moves)
-     No
-
-    ?- length(X,13423), solution([w,w,w,w],X).
-     [goat, goat, goat, goat, goat, goat, goat, ....., +7 steps] is one of the solutions