diff --git a/Makefile b/Makefile
index e4b2ef8..bfc2bae 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 # My make-fu style is old and tired.  I just want to have a few helper commands.
 
 TESTDIR = ./test00
-VERSION = 0.1.1
+VERSION = 0.2.0
 
 .PHONY: clean sdist test docs
 
diff --git a/README b/README
index d4be03f..602ef05 100644
--- a/README
+++ b/README
@@ -4,7 +4,7 @@
 
   A dialect of Joy in Python.
 
-           v0.1.0
+           v0.2.0
 
 
 --------------------------------------------------
diff --git a/docs/Ordered_Binary_Trees.html b/docs/Ordered_Binary_Trees.html
index e5a218f..d8d3271 100644
--- a/docs/Ordered_Binary_Trees.html
+++ b/docs/Ordered_Binary_Trees.html
@@ -12286,7 +12286,7 @@ key new_value [              left right]                                     con
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Now-we-can-define-Tree-add">Now we can define <code>Tree-add</code><a class="anchor-link" href="#Now-we-can-define-Tree-add">&#182;</a></h4>
+<h3 id="Now-we-can-define-Tree-add">Now we can define <code>Tree-add</code><a class="anchor-link" href="#Now-we-can-define-Tree-add">&#182;</a></h3>
 <pre><code>Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P &gt;] [T] [E] ifte] genrec
 
 </code></pre>
@@ -12322,7 +12322,7 @@ Tree-add == [popop not] [[pop] dipd Tree-new] [] [R] genrec</code></pre>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Examples">Examples<a class="anchor-link" href="#Examples">&#182;</a></h4>
+<h3 id="Examples">Examples<a class="anchor-link" href="#Examples">&#182;</a></h3>
 </div>
 </div>
 </div>
@@ -12820,7 +12820,7 @@ Tree-add == [popop not] [[pop] dipd Tree-new] [] [R] genrec</code></pre>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h3 id="Processing-the-current-node.">Processing the current node.<a class="anchor-link" href="#Processing-the-current-node.">&#182;</a></h3><p><code>R0</code> is almost certainly going to use <code>dup</code> to make a copy of the node and then <code>dip</code> on some function to process the copy with it:</p>
+<h4 id="Processing-the-current-node.">Processing the current node.<a class="anchor-link" href="#Processing-the-current-node.">&#182;</a></h4><p><code>R0</code> is almost certainly going to use <code>dup</code> to make a copy of the node and then <code>dip</code> on some function to process the copy with it:</p>
 
 <pre><code>[key value left right] [F] dupdip                 [Tree-iter] R1
 [key value left right]  F  [key value left right] [Tree-iter] R1
@@ -12841,7 +12841,7 @@ key                            [key value left right] [Tree-iter] R1</code></pre
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h3 id="Recur">Recur<a class="anchor-link" href="#Recur">&#182;</a></h3><p>Now <code>R1</code> needs to apply <code>[Tree-iter]</code> to <code>left</code> and <code>right</code>.  If we drop the key and value from the node using <code>rest</code> twice we are left with an interesting situation:</p>
+<h4 id="Recur">Recur<a class="anchor-link" href="#Recur">&#182;</a></h4><p>Now <code>R1</code> needs to apply <code>[Tree-iter]</code> to <code>left</code> and <code>right</code>.  If we drop the key and value from the node using <code>rest</code> twice we are left with an interesting situation:</p>
 
 <pre><code>key [key value left right] [Tree-iter] R1
 key [key value left right] [Tree-iter] [rest rest] dip
@@ -12907,7 +12907,7 @@ key left-keys right-keys
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h2 id="Tree-iter"><code>Tree-iter</code><a class="anchor-link" href="#Tree-iter">&#182;</a></h2>
+<h3 id="Tree-iter"><code>Tree-iter</code><a class="anchor-link" href="#Tree-iter">&#182;</a></h3>
 <pre><code>Tree-iter == [not] [pop] roll&lt; [dupdip rest rest] cons [step] genrec</code></pre>
 
 </div>
@@ -12930,7 +12930,7 @@ key left-keys right-keys
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Examples">Examples<a class="anchor-link" href="#Examples">&#182;</a></h4>
+<h3 id="Examples">Examples<a class="anchor-link" href="#Examples">&#182;</a></h3>
 </div>
 </div>
 </div>
@@ -13192,7 +13192,7 @@ key left-keys right-keys
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Process-the-left-child.">Process the left child.<a class="anchor-link" href="#Process-the-left-child.">&#182;</a></h4><p>Staring at this for a bit suggests <code>dup third</code> to start:</p>
+<h3 id="Process-the-left-child.">Process the left child.<a class="anchor-link" href="#Process-the-left-child.">&#182;</a></h3><p>Staring at this for a bit suggests <code>dup third</code> to start:</p>
 
 <pre><code>[key value left right] R0        [Tree-iter-order] R1
 [key value left right] dup third [Tree-iter-order] R1
@@ -13219,7 +13219,7 @@ left Tree-iter-order [key value left right]             [Tree-iter-order]</code>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Process-the-current-node.">Process the current node.<a class="anchor-link" href="#Process-the-current-node.">&#182;</a></h4><p>So far, so good.  Now we need to process the current node's values:</p>
+<h3 id="Process-the-current-node.">Process the current node.<a class="anchor-link" href="#Process-the-current-node.">&#182;</a></h3><p>So far, so good.  Now we need to process the current node's values:</p>
 
 <pre><code>left Tree-iter-order [key value left right] [Tree-iter-order] [[F] dupdip] dip
 left Tree-iter-order [key value left right] [F] dupdip [Tree-iter-order]
@@ -13238,7 +13238,7 @@ left Tree-iter-order key [key value left right] [Tree-iter-order]</code></pre>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Process-the-right-child.">Process the right child.<a class="anchor-link" href="#Process-the-right-child.">&#182;</a></h4><p>First ditch the rest of the node and get the right child:</p>
+<h3 id="Process-the-right-child.">Process the right child.<a class="anchor-link" href="#Process-the-right-child.">&#182;</a></h3><p>First ditch the rest of the node and get the right child:</p>
 
 <pre><code>left Tree-iter-order key [key value left right] [Tree-iter-order] [rest rest rest first] dip
 left Tree-iter-order key right [Tree-iter-order]
@@ -13256,7 +13256,7 @@ left Tree-iter-order key right Tree-iter-order</code></pre>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Defining-Tree-iter-order">Defining <code>Tree-iter-order</code><a class="anchor-link" href="#Defining-Tree-iter-order">&#182;</a></h4><p>The result is a little awkward:</p>
+<h3 id="Defining-Tree-iter-order">Defining <code>Tree-iter-order</code><a class="anchor-link" href="#Defining-Tree-iter-order">&#182;</a></h3><p>The result is a little awkward:</p>
 
 <pre><code>R1 == [cons dip] dupdip [[F] dupdip] dip [rest rest rest first] dip i
 
@@ -13372,7 +13372,7 @@ Tree-iter-order == [not] [pop] [dup third] [proc_left proc_current proc_right] g
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="The-base-case-[]">The base case <code>[]</code><a class="anchor-link" href="#The-base-case-[]">&#182;</a></h4><p>As before, the stopping predicate just has to detect the empty list:</p>
+<h3 id="The-base-case-[]">The base case <code>[]</code><a class="anchor-link" href="#The-base-case-[]">&#182;</a></h3><p>As before, the stopping predicate just has to detect the empty list:</p>
 
 <pre><code>Tree-get == [pop not] [E] [R0] [R1] genrec
 
@@ -13399,7 +13399,7 @@ tree key [pop not] [E] [R0] [R1] genrec
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Node-case-[key-value-left-right]">Node case <code>[key value left right]</code><a class="anchor-link" href="#Node-case-[key-value-left-right]">&#182;</a></h4><p>Now we need to figure out <code>R0</code> and <code>R1</code>:</p>
+<h3 id="Node-case-[key-value-left-right]">Node case <code>[key value left right]</code><a class="anchor-link" href="#Node-case-[key-value-left-right]">&#182;</a></h3><p>Now we need to figure out <code>R0</code> and <code>R1</code>:</p>
 
 <pre><code>[key value left right] key R0 [BTree-get] R1
 
@@ -13415,7 +13415,7 @@ tree key [pop not] [E] [R0] [R1] genrec
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h4 id="Predicate:">Predicate:<a class="anchor-link" href="#Predicate:">&#182;</a></h4>
+<h4 id="Predicate">Predicate<a class="anchor-link" href="#Predicate">&#182;</a></h4>
 <pre><code>P == over [get-node-key] nullary
 get-node-key == pop popop first
 
@@ -13670,7 +13670,7 @@ Tree-get == [pop not] swap [] [P [T&gt;] [E] [T&lt;] cmp] genrec</code></pre>
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h1 id="Tree-delete">Tree-delete<a class="anchor-link" href="#Tree-delete">&#182;</a></h1><p>Now let's write a function that can return a tree datastructure with a key, value pair deleted:</p>
+<h2 id="Tree-delete">Tree-delete<a class="anchor-link" href="#Tree-delete">&#182;</a></h2><p>Now let's write a function that can return a tree datastructure with a key, value pair deleted:</p>
 
 <pre><code>   tree key Tree-delete
 ---------------------------
diff --git a/docs/Ordered_Binary_Trees.ipynb b/docs/Ordered_Binary_Trees.ipynb
index c9dfffe..27a8513 100644
--- a/docs/Ordered_Binary_Trees.ipynb
+++ b/docs/Ordered_Binary_Trees.ipynb
@@ -386,7 +386,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Now we can define `Tree-add`\n",
+    "### Now we can define `Tree-add`\n",
     "    Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec\n",
     "\n",
     "Putting it all together:\n",
@@ -415,7 +415,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Examples"
+    "### Examples"
    ]
   },
   {
@@ -751,7 +751,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Processing the current node.\n",
+    "#### Processing the current node.\n",
     "\n",
     "`R0` is almost certainly going to use `dup` to make a copy of the node and then `dip` on some function to process the copy with it:\n",
     "\n",
@@ -771,7 +771,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Recur\n",
+    "#### Recur\n",
     "Now `R1` needs to apply `[Tree-iter]` to `left` and `right`.  If we drop the key and value from the node using `rest` twice we are left with an interesting situation:\n",
     "\n",
     "    key [key value left right] [Tree-iter] R1\n",
@@ -829,7 +829,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## `Tree-iter`\n",
+    "### `Tree-iter`\n",
     "\n",
     "    Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec"
    ]
@@ -847,7 +847,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Examples"
+    "### Examples"
    ]
   },
   {
@@ -1011,7 +1011,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Process the left child.\n",
+    "### Process the left child.\n",
     "Staring at this for a bit suggests `dup third` to start:\n",
     "\n",
     "    [key value left right] R0        [Tree-iter-order] R1\n",
@@ -1035,7 +1035,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Process the current node.\n",
+    "### Process the current node.\n",
     "So far, so good.  Now we need to process the current node's values:\n",
     "\n",
     "    left Tree-iter-order [key value left right] [Tree-iter-order] [[F] dupdip] dip\n",
@@ -1052,7 +1052,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Process the right child.\n",
+    "### Process the right child.\n",
     "First ditch the rest of the node and get the right child:\n",
     "\n",
     "    left Tree-iter-order key [key value left right] [Tree-iter-order] [rest rest rest first] dip\n",
@@ -1068,7 +1068,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Defining `Tree-iter-order`\n",
+    "### Defining `Tree-iter-order`\n",
     "The result is a little awkward:\n",
     "\n",
     "    R1 == [cons dip] dupdip [[F] dupdip] dip [rest rest rest first] dip i\n",
@@ -1163,7 +1163,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### The base case `[]`\n",
+    "### The base case `[]`\n",
     "As before, the stopping predicate just has to detect the empty list:\n",
     "\n",
     "    Tree-get == [pop not] [E] [R0] [R1] genrec\n",
@@ -1186,7 +1186,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Node case `[key value left right]`\n",
+    "### Node case `[key value left right]`\n",
     "Now we need to figure out `R0` and `R1`: \n",
     "\n",
     "    [key value left right] key R0 [BTree-get] R1\n",
@@ -1200,7 +1200,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Predicate:\n",
+    "#### Predicate\n",
     "\n",
     "    P == over [get-node-key] nullary\n",
     "    get-node-key == pop popop first\n",
@@ -1386,7 +1386,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Tree-delete\n",
+    "## Tree-delete\n",
     "\n",
     "Now let's write a function that can return a tree datastructure with a key, value pair deleted:\n",
     "\n",
diff --git a/docs/Ordered_Binary_Trees.md b/docs/Ordered_Binary_Trees.md
index adecfb7..6545c29 100644
--- a/docs/Ordered_Binary_Trees.md
+++ b/docs/Ordered_Binary_Trees.md
@@ -234,7 +234,7 @@ J('["k" "old_value" "left" "right"] "new_value" "k" ["Tree-add"] Ee')
     ['k' 'new_value' 'left' 'right']
 
 
-#### Now we can define `Tree-add`
+### Now we can define `Tree-add`
     Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec
 
 Putting it all together:
@@ -254,7 +254,7 @@ Putting it all together:
 define('Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec')
 ```
 
-#### Examples
+### Examples
 
 
 ```python
@@ -426,7 +426,7 @@ Let's look at it *in situ*:
 
     [key value left right] R0 [Tree-iter] R1
 
-### Processing the current node.
+#### Processing the current node.
 
 `R0` is almost certainly going to use `dup` to make a copy of the node and then `dip` on some function to process the copy with it:
 
@@ -441,7 +441,7 @@ For example, if we're getting all the keys `F` would be `first`:
     [key value left right]  first  [key value left right] [Tree-iter] R1
     key                            [key value left right] [Tree-iter] R1
 
-### Recur
+#### Recur
 Now `R1` needs to apply `[Tree-iter]` to `left` and `right`.  If we drop the key and value from the node using `rest` twice we are left with an interesting situation:
 
     key [key value left right] [Tree-iter] R1
@@ -484,7 +484,7 @@ Working backward:
     [not] [pop] [F]       [dupdip rest rest] cons [step] genrec
     [F] [not] [pop] roll< [dupdip rest rest] cons [step] genrec
 
-## `Tree-iter`
+### `Tree-iter`
 
     Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec
 
@@ -493,7 +493,7 @@ Working backward:
 define('Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec')
 ```
 
-#### Examples
+### Examples
 
 
 ```python
@@ -568,7 +568,7 @@ To define `R0` and `R1` it helps to look at them as they will appear when they r
 
     [key value left right] R0 [BTree-iter-order] R1
 
-#### Process the left child.
+### Process the left child.
 Staring at this for a bit suggests `dup third` to start:
 
     [key value left right] R0        [Tree-iter-order] R1
@@ -582,7 +582,7 @@ Now maybe:
     [key value left right] [left Tree-iter-order]       dip [Tree-iter-order]
     left Tree-iter-order [key value left right]             [Tree-iter-order]
 
-#### Process the current node.
+### Process the current node.
 So far, so good.  Now we need to process the current node's values:
 
     left Tree-iter-order [key value left right] [Tree-iter-order] [[F] dupdip] dip
@@ -594,7 +594,7 @@ If `F` needs items from the stack below the left stuff it should have `cons`'d t
     left Tree-iter-order [key value left right] first [key value left right] [Tree-iter-order]
     left Tree-iter-order key [key value left right] [Tree-iter-order]
 
-#### Process the right child.
+### Process the right child.
 First ditch the rest of the node and get the right child:
 
     left Tree-iter-order key [key value left right] [Tree-iter-order] [rest rest rest first] dip
@@ -605,7 +605,7 @@ Then, of course, we just need `i` to run `Tree-iter-order` on the right side:
     left Tree-iter-order key right [Tree-iter-order] i
     left Tree-iter-order key right Tree-iter-order
 
-#### Defining `Tree-iter-order`
+### Defining `Tree-iter-order`
 The result is a little awkward:
 
     R1 == [cons dip] dupdip [[F] dupdip] dip [rest rest rest first] dip i
@@ -673,7 +673,7 @@ Let's pass the buck to the caller by making the base case a given, you have to d
     ---------------------------- key not in tree
              [] key E
 
-#### The base case `[]`
+### The base case `[]`
 As before, the stopping predicate just has to detect the empty list:
 
     Tree-get == [pop not] [E] [R0] [R1] genrec
@@ -691,7 +691,7 @@ The anonymous specialized recursive function that will do the real work.
 
     [pop not] [E] [R0] [R1] genrec
 
-#### Node case `[key value left right]`
+### Node case `[key value left right]`
 Now we need to figure out `R0` and `R1`: 
 
     [key value left right] key R0 [BTree-get] R1
@@ -700,7 +700,7 @@ We want to compare the search key with the key in the node, and if they are the
 
     [key value left right] key [BTree-get] P [T>] [E] [T<] cmp
 
-#### Predicate:
+#### Predicate
 
     P == over [get-node-key] nullary
     get-node-key == pop popop first
@@ -821,7 +821,7 @@ J('''
     'not found'
 
 
-# Tree-delete
+## Tree-delete
 
 Now let's write a function that can return a tree datastructure with a key, value pair deleted:
 
diff --git a/docs/Ordered_Binary_Trees.rst b/docs/Ordered_Binary_Trees.rst
index 612fd66..77e3bbc 100644
--- a/docs/Ordered_Binary_Trees.rst
+++ b/docs/Ordered_Binary_Trees.rst
@@ -336,7 +336,7 @@ Example:
 
 
 Now we can define ``Tree-add``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ::
 
@@ -361,7 +361,7 @@ Putting it all together:
     define('Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec')
 
 Examples
-^^^^^^^^
+~~~~~~~~
 
 .. code:: ipython2
 
@@ -594,7 +594,7 @@ Let's look at it *in situ*:
     [key value left right] R0 [Tree-iter] R1
 
 Processing the current node.
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``R0`` is almost certainly going to use ``dup`` to make a copy of the
 node and then ``dip`` on some function to process the copy with it:
@@ -615,7 +615,7 @@ For example, if we're getting all the keys ``F`` would be ``first``:
     key                            [key value left right] [Tree-iter] R1
 
 Recur
-~~~~~
+^^^^^
 
 Now ``R1`` needs to apply ``[Tree-iter]`` to ``left`` and ``right``. If
 we drop the key and value from the node using ``rest`` twice we are left
@@ -680,7 +680,7 @@ Working backward:
     [F] [not] [pop] roll< [dupdip rest rest] cons [step] genrec
 
 ``Tree-iter``
--------------
+~~~~~~~~~~~~~
 
 ::
 
@@ -691,7 +691,7 @@ Working backward:
     define('Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec')
 
 Examples
-^^^^^^^^
+~~~~~~~~
 
 .. code:: ipython2
 
@@ -793,7 +793,7 @@ when they run:
     [key value left right] R0 [BTree-iter-order] R1
 
 Process the left child.
-^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~
 
 Staring at this for a bit suggests ``dup third`` to start:
 
@@ -813,7 +813,7 @@ Now maybe:
     left Tree-iter-order [key value left right]             [Tree-iter-order]
 
 Process the current node.
-^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
 So far, so good. Now we need to process the current node's values:
 
@@ -833,7 +833,7 @@ works fine as-is.
     left Tree-iter-order key [key value left right] [Tree-iter-order]
 
 Process the right child.
-^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~
 
 First ditch the rest of the node and get the right child:
 
@@ -851,7 +851,7 @@ right side:
     left Tree-iter-order key right Tree-iter-order
 
 Defining ``Tree-iter-order``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The result is a little awkward:
 
@@ -938,7 +938,7 @@ have to decide for yourself what ``[E]`` should be.
              [] key E
 
 The base case ``[]``
-^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~
 
 As before, the stopping predicate just has to detect the empty list:
 
@@ -969,7 +969,7 @@ The anonymous specialized recursive function that will do the real work.
     [pop not] [E] [R0] [R1] genrec
 
 Node case ``[key value left right]``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now we need to figure out ``R0`` and ``R1``:
 
@@ -986,8 +986,8 @@ and ``R1 == P [T>] [E] [T<] cmp``:
 
     [key value left right] key [BTree-get] P [T>] [E] [T<] cmp
 
-Predicate:
-^^^^^^^^^^
+Predicate
+^^^^^^^^^
 
 ::
 
@@ -1142,7 +1142,7 @@ So:
 
 
 Tree-delete
-===========
+-----------
 
 Now let's write a function that can return a tree datastructure with a
 key, value pair deleted:
diff --git a/docs/Treestep.html b/docs/Treestep.html
index 94e8180..684d54f 100644
--- a/docs/Treestep.html
+++ b/docs/Treestep.html
@@ -11775,7 +11775,7 @@ div#notebook {
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h1 id="Treating-Trees-II">Treating Trees II<a class="anchor-link" href="#Treating-Trees-II">&#182;</a></h1><p>Let's consider a tree structure, similar to one described <a href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">"Why functional programming matters" by John Hughes</a>, that consists of a node value followed by a sequence of zero or more child trees.  (The asterisk is meant to indicate the <a href="https://en.wikipedia.org/wiki/Kleene_star">Kleene star</a>.)</p>
+<h1 id="Treating-Trees-II:-treestep">Treating Trees II: <code>treestep</code><a class="anchor-link" href="#Treating-Trees-II:-treestep">&#182;</a></h1><p>Let's consider a tree structure, similar to one described <a href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">"Why functional programming matters" by John Hughes</a>, that consists of a node value followed by zero or more child trees.  (The asterisk is meant to indicate the <a href="https://en.wikipedia.org/wiki/Kleene_star">Kleene star</a>.)</p>
 
 <pre><code>tree = [] | [node tree*]</code></pre>
 
@@ -11786,7 +11786,7 @@ div#notebook {
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h2 id="treestep"><code>treestep</code><a class="anchor-link" href="#treestep">&#182;</a></h2><p>In the spirit of <code>step</code> we are going to define a combinator <code>treestep</code> which expects a tree and three additional items: a base-case function <code>[B]</code>, and two quoted programs <code>[N]</code> and <code>[C]</code>.</p>
+<p>In the spirit of <code>step</code> we are going to define a combinator <code>treestep</code> which expects a tree and three additional items: a base-case function <code>[B]</code>, and two quoted programs <code>[N]</code> and <code>[C]</code>.</p>
 
 <pre><code>tree [B] [N] [C] treestep</code></pre>
 
@@ -12927,46 +12927,6 @@ Tree-get == [P [T&gt;] [E] [T&lt;] cmp] treegrind
 <div class="cell border-box-sizing code_cell rendered">
 <div class="input">
 <div class="prompt input_prompt">In&nbsp;[23]:</div>
-<div class="inner_cell">
-    <div class="input_area">
-<div class=" highlight hl-ipython2"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="kn">import</span> <span class="n">FunctionWrapper</span>
-<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="kn">import</span> <span class="n">pushback</span>
-
-
-<span class="nd">@FunctionWrapper</span>
-<span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
-    <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">    cmp takes two values and three quoted programs on the stack and runs</span>
-<span class="sd">    one of the three depending on the results of comparing the two values:</span>
-
-<span class="sd">           a b [G] [E] [L] cmp</span>
-<span class="sd">        ------------------------- a &gt; b</span>
-<span class="sd">                G</span>
-
-<span class="sd">           a b [G] [E] [L] cmp</span>
-<span class="sd">        ------------------------- a = b</span>
-<span class="sd">                    E</span>
-
-<span class="sd">           a b [G] [E] [L] cmp</span>
-<span class="sd">        ------------------------- a &lt; b</span>
-<span class="sd">                        L</span>
-<span class="sd">    &#39;&#39;&#39;</span>
-    <span class="n">L</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
-    <span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
-    <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
-
-
-<span class="n">D</span><span class="p">[</span><span class="s1">&#39;cmp&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">cmp_</span>
-</pre></div>
-
-</div>
-</div>
-</div>
-
-</div>
-<div class="cell border-box-sizing code_cell rendered">
-<div class="input">
-<div class="prompt input_prompt">In&nbsp;[24]:</div>
 <div class="inner_cell">
     <div class="input_area">
 <div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
@@ -13003,7 +12963,7 @@ Tree-get == [P [T&gt;] [E] [T&lt;] cmp] treegrind
 </div>
 <div class="cell border-box-sizing code_cell rendered">
 <div class="input">
-<div class="prompt input_prompt">In&nbsp;[25]:</div>
+<div class="prompt input_prompt">In&nbsp;[24]:</div>
 <div class="inner_cell">
     <div class="input_area">
 <div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
diff --git a/docs/Treestep.ipynb b/docs/Treestep.ipynb
index 6eb1c5e..0929064 100644
--- a/docs/Treestep.ipynb
+++ b/docs/Treestep.ipynb
@@ -4,8 +4,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Treating Trees II\n",
-    "Let's consider a tree structure, similar to one described [\"Why functional programming matters\" by John Hughes](https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf), that consists of a node value followed by a sequence of zero or more child trees.  (The asterisk is meant to indicate the [Kleene star](https://en.wikipedia.org/wiki/Kleene_star).)\n",
+    "# Treating Trees II: `treestep`\n",
+    "Let's consider a tree structure, similar to one described [\"Why functional programming matters\" by John Hughes](https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf), that consists of a node value followed by zero or more child trees.  (The asterisk is meant to indicate the [Kleene star](https://en.wikipedia.org/wiki/Kleene_star).)\n",
     "\n",
     "    tree = [] | [node tree*]"
    ]
@@ -14,7 +14,6 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## `treestep`\n",
     "In the spirit of `step` we are going to define a combinator `treestep` which expects a tree and three additional items: a base-case function `[B]`, and two quoted programs `[N]` and `[C]`.\n",
     "\n",
     "    tree [B] [N] [C] treestep"
@@ -829,42 +828,6 @@
    "cell_type": "code",
    "execution_count": 23,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "from joy.library import FunctionWrapper\n",
-    "from joy.utils.stack import pushback\n",
-    "\n",
-    "\n",
-    "@FunctionWrapper\n",
-    "def cmp_(stack, expression, dictionary):\n",
-    "    '''\n",
-    "    cmp takes two values and three quoted programs on the stack and runs\n",
-    "    one of the three depending on the results of comparing the two values:\n",
-    "\n",
-    "           a b [G] [E] [L] cmp\n",
-    "        ------------------------- a > b\n",
-    "                G\n",
-    "\n",
-    "           a b [G] [E] [L] cmp\n",
-    "        ------------------------- a = b\n",
-    "                    E\n",
-    "\n",
-    "           a b [G] [E] [L] cmp\n",
-    "        ------------------------- a < b\n",
-    "                        L\n",
-    "    '''\n",
-    "    L, (E, (G, (b, (a, stack)))) = stack\n",
-    "    expression = pushback(G if a > b else L if a < b else E, expression)\n",
-    "    return stack, expression, dictionary\n",
-    "\n",
-    "\n",
-    "D['cmp'] = cmp_"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -886,7 +849,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -906,13 +869,6 @@
     "\n",
     "''')"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/Treestep.md b/docs/Treestep.md
index 60a0573..ce6ce4a 100644
--- a/docs/Treestep.md
+++ b/docs/Treestep.md
@@ -1,10 +1,9 @@
 
-# Treating Trees II
-Let's consider a tree structure, similar to one described ["Why functional programming matters" by John Hughes](https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf), that consists of a node value followed by a sequence of zero or more child trees.  (The asterisk is meant to indicate the [Kleene star](https://en.wikipedia.org/wiki/Kleene_star).)
+# Treating Trees II: `treestep`
+Let's consider a tree structure, similar to one described ["Why functional programming matters" by John Hughes](https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf), that consists of a node value followed by zero or more child trees.  (The asterisk is meant to indicate the [Kleene star](https://en.wikipedia.org/wiki/Kleene_star).)
 
     tree = [] | [node tree*]
 
-## `treestep`
 In the spirit of `step` we are going to define a combinator `treestep` which expects a tree and three additional items: a base-case function `[B]`, and two quoted programs `[N]` and `[C]`.
 
     tree [B] [N] [C] treestep
@@ -439,38 +438,6 @@ DefinitionWrapper.add_definitions('''
 ```
 
 
-```python
-from joy.library import FunctionWrapper
-from joy.utils.stack import pushback
-
-
-@FunctionWrapper
-def cmp_(stack, expression, dictionary):
-    '''
-    cmp takes two values and three quoted programs on the stack and runs
-    one of the three depending on the results of comparing the two values:
-
-           a b [G] [E] [L] cmp
-        ------------------------- a > b
-                G
-
-           a b [G] [E] [L] cmp
-        ------------------------- a = b
-                    E
-
-           a b [G] [E] [L] cmp
-        ------------------------- a < b
-                        L
-    '''
-    L, (E, (G, (b, (a, stack)))) = stack
-    expression = pushback(G if a > b else L if a < b else E, expression)
-    return stack, expression, dictionary
-
-
-D['cmp'] = cmp_
-```
-
-
 ```python
 J('''\
 
diff --git a/docs/Treestep.rst b/docs/Treestep.rst
index 8e2721c..a693d60 100644
--- a/docs/Treestep.rst
+++ b/docs/Treestep.rst
@@ -1,21 +1,18 @@
 
-Treating Trees II
-=================
+Treating Trees II: ``treestep``
+===============================
 
 Let's consider a tree structure, similar to one described `"Why
 functional programming matters" by John
 Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__,
-that consists of a node value followed by a sequence of zero or more
-child trees. (The asterisk is meant to indicate the `Kleene
+that consists of a node value followed by zero or more child trees. (The
+asterisk is meant to indicate the `Kleene
 star <https://en.wikipedia.org/wiki/Kleene_star>`__.)
 
 ::
 
     tree = [] | [node tree*]
 
-``treestep``
-------------
-
 In the spirit of ``step`` we are going to define a combinator
 ``treestep`` which expects a tree and three additional items: a
 base-case function ``[B]``, and two quoted programs ``[N]`` and ``[C]``.
@@ -591,37 +588,6 @@ To me, that seems simpler than the ``genrec`` version.
     
     ''', D)
 
-.. code:: ipython2
-
-    from joy.library import FunctionWrapper
-    from joy.utils.stack import pushback
-    
-    
-    @FunctionWrapper
-    def cmp_(stack, expression, dictionary):
-        '''
-        cmp takes two values and three quoted programs on the stack and runs
-        one of the three depending on the results of comparing the two values:
-    
-               a b [G] [E] [L] cmp
-            ------------------------- a > b
-                    G
-    
-               a b [G] [E] [L] cmp
-            ------------------------- a = b
-                        E
-    
-               a b [G] [E] [L] cmp
-            ------------------------- a < b
-                            L
-        '''
-        L, (E, (G, (b, (a, stack)))) = stack
-        expression = pushback(G if a > b else L if a < b else E, expression)
-        return stack, expression, dictionary
-    
-    
-    D['cmp'] = cmp_
-
 .. code:: ipython2
 
     J('''\
diff --git a/docs/sphinx_docs/_build/html/_modules/index.html b/docs/sphinx_docs/_build/html/_modules/index.html
index 79267e8..2908d2d 100644
--- a/docs/sphinx_docs/_build/html/_modules/index.html
+++ b/docs/sphinx_docs/_build/html/_modules/index.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Overview: module code &#8212; Thun 0.1.1 documentation</title>
+    <title>Overview: module code &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/_modules/joy/joy.html b/docs/sphinx_docs/_build/html/_modules/joy/joy.html
index a0aff00..bf0f436 100644
--- a/docs/sphinx_docs/_build/html/_modules/joy/joy.html
+++ b/docs/sphinx_docs/_build/html/_modules/joy/joy.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>joy.joy &#8212; Thun 0.1.1 documentation</title>
+    <title>joy.joy &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/_modules/joy/library.html b/docs/sphinx_docs/_build/html/_modules/joy/library.html
index 06c4a01..b3c1333 100644
--- a/docs/sphinx_docs/_build/html/_modules/joy/library.html
+++ b/docs/sphinx_docs/_build/html/_modules/joy/library.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>joy.library &#8212; Thun 0.1.1 documentation</title>
+    <title>joy.library &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../../_static/documentation_options.js"></script>
@@ -1173,6 +1173,43 @@
   <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 
 
+<div class="viewcode-block" id="cond"><a class="viewcode-back" href="../../library.html#joy.library.cond">[docs]</a><span class="nd">@inscribe</span>
+<span class="nd">@FunctionWrapper</span>
+<span class="k">def</span> <span class="nf">cond</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
+  <span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">  like a case statement; works by rewriting into a chain of ifte.</span>
+
+<span class="sd">  [..[[Bi] Ti]..[D]] -&gt; ...</span>
+
+
+<span class="sd">        [[[B0] T0] [[B1] T1] [D]] cond</span>
+<span class="sd">  -----------------------------------------</span>
+<span class="sd">     [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
+
+<span class="sd">  &#39;&#39;&#39;</span>
+  <span class="n">conditions</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
+  <span class="k">if</span> <span class="n">conditions</span><span class="p">:</span>
+    <span class="n">expression</span> <span class="o">=</span> <span class="n">_cond</span><span class="p">(</span><span class="n">conditions</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
+    <span class="k">try</span><span class="p">:</span>
+      <span class="c1"># Attempt to preload the args to first ifte.</span>
+      <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span> <span class="o">=</span> <span class="n">expression</span>
+    <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+      <span class="c1"># If, for any reason, the argument to cond should happen to contain</span>
+      <span class="c1"># only the default clause then this optimization will fail.</span>
+      <span class="k">pass</span>
+    <span class="k">else</span><span class="p">:</span>
+      <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span>
+  <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
+
+
+<span class="k">def</span> <span class="nf">_cond</span><span class="p">(</span><span class="n">conditions</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
+  <span class="p">(</span><span class="n">clause</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span> <span class="o">=</span> <span class="n">conditions</span>
+  <span class="k">if</span> <span class="ow">not</span> <span class="n">rest</span><span class="p">:</span>  <span class="c1"># clause is [D]</span>
+    <span class="k">return</span> <span class="n">clause</span>
+  <span class="n">P</span><span class="p">,</span> <span class="n">T</span> <span class="o">=</span> <span class="n">clause</span>
+  <span class="k">return</span> <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">_cond</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="p">()),</span> <span class="p">(</span><span class="n">S_ifte</span><span class="p">,</span> <span class="n">expression</span><span class="p">))))</span>
+
+
 <div class="viewcode-block" id="dip"><a class="viewcode-back" href="../../library.html#joy.library.dip">[docs]</a><span class="nd">@inscribe</span>
 <span class="nd">@FunctionWrapper</span>
 <span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
@@ -1393,6 +1430,30 @@
   <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 
 
+<div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
+<span class="nd">@FunctionWrapper</span>
+<span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
+    <span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">    cmp takes two values and three quoted programs on the stack and runs</span>
+<span class="sd">    one of the three depending on the results of comparing the two values:</span>
+
+<span class="sd">           a b [G] [E] [L] cmp</span>
+<span class="sd">        ------------------------- a &gt; b</span>
+<span class="sd">                G</span>
+
+<span class="sd">           a b [G] [E] [L] cmp</span>
+<span class="sd">        ------------------------- a = b</span>
+<span class="sd">                    E</span>
+
+<span class="sd">           a b [G] [E] [L] cmp</span>
+<span class="sd">        ------------------------- a &lt; b</span>
+<span class="sd">                        L</span>
+<span class="sd">    &#39;&#39;&#39;</span>
+    <span class="n">L</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
+    <span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
+    <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
+
+
 <span class="c1">#def nullary(S, expression, dictionary):</span>
 <span class="c1">#  &#39;&#39;&#39;</span>
 <span class="c1">#  Run the program on TOS and return its first result without consuming</span>
diff --git a/docs/sphinx_docs/_build/html/_modules/joy/parser.html b/docs/sphinx_docs/_build/html/_modules/joy/parser.html
index a847615..20ee021 100644
--- a/docs/sphinx_docs/_build/html/_modules/joy/parser.html
+++ b/docs/sphinx_docs/_build/html/_modules/joy/parser.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>joy.parser &#8212; Thun 0.1.1 documentation</title>
+    <title>joy.parser &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html b/docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html
index 6bc0d94..6f24681 100644
--- a/docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html
+++ b/docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>joy.utils.pretty_print &#8212; Thun 0.1.1 documentation</title>
+    <title>joy.utils.pretty_print &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../../../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../../../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html b/docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html
index 01cb345..7b6c19b 100644
--- a/docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html
+++ b/docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>joy.utils.stack &#8212; Thun 0.1.1 documentation</title>
+    <title>joy.utils.stack &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../../../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../../../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/_static/documentation_options.js b/docs/sphinx_docs/_build/html/_static/documentation_options.js
index d1cc82f..a0c35f6 100644
--- a/docs/sphinx_docs/_build/html/_static/documentation_options.js
+++ b/docs/sphinx_docs/_build/html/_static/documentation_options.js
@@ -1,6 +1,6 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: '',
-    VERSION: '0.1.1',
+    VERSION: '0.2.0',
     LANGUAGE: 'None',
     COLLAPSE_INDEX: false,
     FILE_SUFFIX: '.html',
diff --git a/docs/sphinx_docs/_build/html/genindex.html b/docs/sphinx_docs/_build/html/genindex.html
index 6eb5d7f..e0c5224 100644
--- a/docs/sphinx_docs/_build/html/genindex.html
+++ b/docs/sphinx_docs/_build/html/genindex.html
@@ -7,7 +7,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Index &#8212; Thun 0.1.1 documentation</title>
+    <title>Index &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
@@ -99,10 +99,14 @@
       <li><a href="library.html#joy.library.choice">choice() (in module joy.library)</a>
 </li>
       <li><a href="library.html#joy.library.clear">clear() (in module joy.library)</a>
+</li>
+      <li><a href="library.html#joy.library.cmp_">cmp_() (in module joy.library)</a>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="library.html#joy.library.concat">concat() (in module joy.library)</a>
+</li>
+      <li><a href="library.html#joy.library.cond">cond() (in module joy.library)</a>
 </li>
       <li><a href="library.html#joy.library.cons">cons() (in module joy.library)</a>
 </li>
diff --git a/docs/sphinx_docs/_build/html/index.html b/docs/sphinx_docs/_build/html/index.html
index 4f0e5dc..e06d2e9 100644
--- a/docs/sphinx_docs/_build/html/index.html
+++ b/docs/sphinx_docs/_build/html/index.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Thun 0.1.1 Documentation &#8212; Thun 0.1.1 documentation</title>
+    <title>Thun 0.2.0 Documentation &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
@@ -32,7 +32,7 @@
           <div class="body" role="main">
             
   <div class="section" id="thun-release-documentation">
-<h1>Thun 0.1.1 Documentation<a class="headerlink" href="#thun-release-documentation" title="Permalink to this headline">¶</a></h1>
+<h1>Thun 0.2.0 Documentation<a class="headerlink" href="#thun-release-documentation" title="Permalink to this headline">¶</a></h1>
 <p>Thun is dialect of Joy written in Python 2.</p>
 <p><a class="reference external" href="https://en.wikipedia.org/wiki/Joy_(programming_language)">Joy</a> is a programming language created by Manfred von Thun that is easy to
 use and understand and has many other nice properties.  This Python
@@ -133,7 +133,8 @@ interesting aspects.  It’s quite a treasure trove.</p>
 <li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Developing.html">Developing a Program in Joy</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Replacing.html">Replacing Functions in the Dictionary</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebooks/Trees.html">Treating Trees</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebooks/Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebooks/Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Newton-Raphson.html">Newton’s method</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Quadratic.html">Quadratic formula</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/NoUpdates.html">No Updates</a></li>
@@ -161,7 +162,7 @@ interesting aspects.  It’s quite a treasure trove.</p>
         <div class="sphinxsidebarwrapper">
   <h3><a href="#">Table Of Contents</a></h3>
   <ul>
-<li><a class="reference internal" href="#">Thun 0.1.1 Documentation</a><ul>
+<li><a class="reference internal" href="#">Thun 0.2.0 Documentation</a><ul>
 <li><a class="reference internal" href="#quick-start">Quick Start</a></li>
 <li><a class="reference internal" href="#project-hosted-on-osdn">Project Hosted on OSDN</a></li>
 <li><a class="reference internal" href="#information-on-the-joy-language">Information on the Joy language</a></li>
diff --git a/docs/sphinx_docs/_build/html/joy.html b/docs/sphinx_docs/_build/html/joy.html
index 5c31265..d5d82a1 100644
--- a/docs/sphinx_docs/_build/html/joy.html
+++ b/docs/sphinx_docs/_build/html/joy.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Joy Interpreter &#8212; Thun 0.1.1 documentation</title>
+    <title>Joy Interpreter &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/lib.html b/docs/sphinx_docs/_build/html/lib.html
index cb9e41b..4e964fd 100644
--- a/docs/sphinx_docs/_build/html/lib.html
+++ b/docs/sphinx_docs/_build/html/lib.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Functions Grouped by, er, Function with Examples &#8212; Thun 0.1.1 documentation</title>
+    <title>Functions Grouped by, er, Function with Examples &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/library.html b/docs/sphinx_docs/_build/html/library.html
index 9af4bec..304a854 100644
--- a/docs/sphinx_docs/_build/html/library.html
+++ b/docs/sphinx_docs/_build/html/library.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Function Reference &#8212; Thun 0.1.1 documentation</title>
+    <title>Function Reference &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
@@ -193,12 +193,48 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
 </div>
 </dd></dl>
 
+<dl class="function">
+<dt id="joy.library.cmp_">
+<code class="descclassname">joy.library.</code><code class="descname">cmp_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cmp_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cmp_" title="Permalink to this definition">¶</a></dt>
+<dd><p>cmp takes two values and three quoted programs on the stack and runs
+one of the three depending on the results of comparing the two values:</p>
+<blockquote>
+<div><blockquote>
+<div>a b [G] [E] [L] cmp</div></blockquote>
+<dl class="docutils">
+<dt>————————- a &gt; b</dt>
+<dd><blockquote class="first">
+<div>G</div></blockquote>
+<p class="last">a b [G] [E] [L] cmp</p>
+</dd>
+<dt>————————- a = b</dt>
+<dd><blockquote class="first">
+<div>E</div></blockquote>
+<p class="last">a b [G] [E] [L] cmp</p>
+</dd>
+<dt>————————- a &lt; b</dt>
+<dd>L</dd>
+</dl>
+</div></blockquote>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.library.concat">
 <code class="descclassname">joy.library.</code><code class="descname">concat</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#concat"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.concat" title="Permalink to this definition">¶</a></dt>
 <dd><p>Concatinate the two lists on the top of the stack.</p>
 </dd></dl>
 
+<dl class="function">
+<dt id="joy.library.cond">
+<code class="descclassname">joy.library.</code><code class="descname">cond</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cond"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cond" title="Permalink to this definition">¶</a></dt>
+<dd><p>like a case statement; works by rewriting into a chain of ifte.</p>
+<p>[..[[Bi] Ti]..[D]] -&gt; …</p>
+<blockquote>
+<div>[[[B0] T0] [[B1] T1] [D]] cond</div></blockquote>
+<blockquote>
+<div>[B0] [T0] [[B1] [T1] [D] ifte] ifte</div></blockquote>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.library.cons">
 <code class="descclassname">joy.library.</code><code class="descname">cons</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cons"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cons" title="Permalink to this definition">¶</a></dt>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 1st.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 1st.html
index 41c2741..065e727 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 1st.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 1st.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 2nd.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 2nd.html
index 832f11d..f6c201d 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 2nd.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 2nd.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 3rd.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 3rd.html
index dd5edcd..3cf675b 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 3rd.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 3rd.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 4th.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 4th.html
index 2ff6dc6..cbc30b7 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 4th.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 4th.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 5th.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 5th.html
index 23cd285..b43719e 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 5th.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 5th.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 6th.html b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 6th.html
index c06b4dd..2de39c8 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 6th.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Advent of Code 2017 December 6th.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Advent of Code 2017 &#8212; Thun 0.1.1 documentation</title>
+    <title>Advent of Code 2017 &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Categorical.html b/docs/sphinx_docs/_build/html/notebooks/Categorical.html
index b407c35..bd7eba0 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Categorical.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Categorical.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Categorical Programming &#8212; Thun 0.1.1 documentation</title>
+    <title>Categorical Programming &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
@@ -39,7 +39,7 @@
 <p>In <a class="reference external" href="http://conal.net/papers/compiling-to-categories/">Compiling to categories</a> Conal Elliott give a taste of what this might mean.</p>
 <blockquote>
 <div>It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.</div></blockquote>
-<p>What he’s doing is translating labda forms into a kind of “point-free” style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.</p>
+<p>What he’s doing is translating lambda forms into a kind of “point-free” style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.</p>
 </div>
 
 
diff --git a/docs/sphinx_docs/_build/html/notebooks/Developing.html b/docs/sphinx_docs/_build/html/notebooks/Developing.html
index c6cd960..c3a6c34 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Developing.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Developing.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Developing a Program in Joy &#8212; Thun 0.1.1 documentation</title>
+    <title>Developing a Program in Joy &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Generator Programs.html b/docs/sphinx_docs/_build/html/notebooks/Generator Programs.html
index d20d464..4c3cc83 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Generator Programs.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Generator Programs.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Using x to Generate Values &#8212; Thun 0.1.1 documentation</title>
+    <title>Using x to Generate Values &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.html b/docs/sphinx_docs/_build/html/notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.html
index b0b7fd0..b82e285 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.html	
+++ b/docs/sphinx_docs/_build/html/notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.html	
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Hylomorphism &#8212; Thun 0.1.1 documentation</title>
+    <title>Hylomorphism &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Intro.html b/docs/sphinx_docs/_build/html/notebooks/Intro.html
index 4fde6b0..61c82d1 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Intro.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Intro.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Thun: Joy in Python &#8212; Thun 0.1.1 documentation</title>
+    <title>Thun: Joy in Python &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
@@ -17,7 +17,7 @@
     <link rel="index" title="Index" href="../genindex.html" />
     <link rel="search" title="Search" href="../search.html" />
     <link rel="next" title="Joy Interpreter" href="../joy.html" />
-    <link rel="prev" title="Thun 0.1.1 Documentation" href="../index.html" />
+    <link rel="prev" title="Thun 0.2.0 Documentation" href="../index.html" />
    
   <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
   
@@ -326,7 +326,7 @@ developing structured processes.</p>
 <h3>Related Topics</h3>
 <ul>
   <li><a href="../index.html">Documentation overview</a><ul>
-      <li>Previous: <a href="../index.html" title="previous chapter">Thun 0.1.1 Documentation</a></li>
+      <li>Previous: <a href="../index.html" title="previous chapter">Thun 0.2.0 Documentation</a></li>
       <li>Next: <a href="../joy.html" title="next chapter">Joy Interpreter</a></li>
   </ul></li>
 </ul>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html b/docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html
index 6688bee..55d71e6 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Newton’s method &#8212; Thun 0.1.1 documentation</title>
+    <title>Newton’s method &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/NoUpdates.html b/docs/sphinx_docs/_build/html/notebooks/NoUpdates.html
index 6e7234d..dddc748 100644
--- a/docs/sphinx_docs/_build/html/notebooks/NoUpdates.html
+++ b/docs/sphinx_docs/_build/html/notebooks/NoUpdates.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>No Updates &#8212; Thun 0.1.1 documentation</title>
+    <title>No Updates &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Quadratic.html b/docs/sphinx_docs/_build/html/notebooks/Quadratic.html
index 101a626..cc8aaf7 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Quadratic.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Quadratic.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Quadratic formula &#8212; Thun 0.1.1 documentation</title>
+    <title>Quadratic formula &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Trees.html b/docs/sphinx_docs/_build/html/notebooks/Trees.html
index d420f7a..c56bb80 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Trees.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Trees.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Treating Trees &#8212; Thun 0.1.1 documentation</title>
+    <title>Treating Trees &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/Zipper.html b/docs/sphinx_docs/_build/html/notebooks/Zipper.html
index 8e70d42..775b613 100644
--- a/docs/sphinx_docs/_build/html/notebooks/Zipper.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Zipper.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Preamble &#8212; Thun 0.1.1 documentation</title>
+    <title>Preamble &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/notebooks/index.html b/docs/sphinx_docs/_build/html/notebooks/index.html
index a75d684..84ee6af 100644
--- a/docs/sphinx_docs/_build/html/notebooks/index.html
+++ b/docs/sphinx_docs/_build/html/notebooks/index.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Essays about Programming in Joy &#8212; Thun 0.1.1 documentation</title>
+    <title>Essays about Programming in Joy &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="../_static/documentation_options.js"></script>
@@ -50,18 +50,27 @@
 <li class="toctree-l2"><a class="reference internal" href="Replacing.html#a-shorter-trace">A shorter trace</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="Trees.html">Treating Trees</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#a-function-to-traverse-a-btree">A Function to Traverse a BTree</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#adding-nodes-to-the-btree">Adding Nodes to the BTree</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#interlude-the-cmp-combinator">Interlude: The <code class="docutils literal notranslate"><span class="pre">cmp</span></code> combinator</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#interlude-factoring-and-naming">Interlude: Factoring and Naming</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#a-version-of-btree-iter-that-does-in-order-traversal">A Version of <code class="docutils literal notranslate"><span class="pre">BTree-iter</span></code> that does In-Order Traversal</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#getting-values-by-key">Getting values by key</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#todo-btree-delete">TODO: BTree-delete</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#tree-with-node-and-list-of-trees">Tree with node and list of trees.</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#miscellaneous-crap">Miscellaneous Crap</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#a-general-form-for-trees">A General Form for Trees</a></li>
-<li class="toctree-l2"><a class="reference internal" href="Trees.html#automatically-deriving-the-recursion-combinator-for-a-data-type">Automatically deriving the recursion combinator for a data type?</a></li>
+<li class="toctree-l1"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#adding-nodes-to-the-tree">Adding Nodes to the Tree</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#interlude-cmp-combinator">Interlude: <code class="docutils literal notranslate"><span class="pre">cmp</span></code> combinator</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#a-function-to-traverse-this-structure">A Function to Traverse this Structure</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#interlude-a-set-like-datastructure">Interlude: A Set-like Datastructure</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#a-version-of-tree-iter-that-does-in-order-traversal">A Version of <code class="docutils literal notranslate"><span class="pre">Tree-iter</span></code> that does In-Order Traversal</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#getting-values-by-key">Getting values by key</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#tree-delete">Tree-delete</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html#appendix-the-source-code">Appendix: The source code.</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a><ul>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#derive-the-recursive-function">Derive the recursive function.</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#extract-the-givens-to-parameterize-the-program">Extract the givens to parameterize the program.</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#define-treestep">Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#examples">Examples</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#redefining-the-ordered-binary-tree-in-terms-of-treestep">Redefining the Ordered Binary Tree in terms of <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#with-treegrind">With <code class="docutils literal notranslate"><span class="pre">treegrind</span></code>?</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#treegrind-with-step"><code class="docutils literal notranslate"><span class="pre">treegrind</span></code> with <code class="docutils literal notranslate"><span class="pre">step</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#do-we-have-the-flexibility-to-reimplement-tree-get">Do we have the flexibility to reimplement <code class="docutils literal notranslate"><span class="pre">Tree-get</span></code>?</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Treestep.html#putting-it-together">Putting it together</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a><ul>
diff --git a/docs/sphinx_docs/_build/html/objects.inv b/docs/sphinx_docs/_build/html/objects.inv
index 8ec420f..27ec52e 100644
Binary files a/docs/sphinx_docs/_build/html/objects.inv and b/docs/sphinx_docs/_build/html/objects.inv differ
diff --git a/docs/sphinx_docs/_build/html/parser.html b/docs/sphinx_docs/_build/html/parser.html
index 98b8ba9..c0cc06b 100644
--- a/docs/sphinx_docs/_build/html/parser.html
+++ b/docs/sphinx_docs/_build/html/parser.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Parsing Text into Joy Expressions &#8212; Thun 0.1.1 documentation</title>
+    <title>Parsing Text into Joy Expressions &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/pretty.html b/docs/sphinx_docs/_build/html/pretty.html
index c16e007..3498c28 100644
--- a/docs/sphinx_docs/_build/html/pretty.html
+++ b/docs/sphinx_docs/_build/html/pretty.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Tracing Joy Execution &#8212; Thun 0.1.1 documentation</title>
+    <title>Tracing Joy Execution &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/py-modindex.html b/docs/sphinx_docs/_build/html/py-modindex.html
index b209fcc..60aec3f 100644
--- a/docs/sphinx_docs/_build/html/py-modindex.html
+++ b/docs/sphinx_docs/_build/html/py-modindex.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Python Module Index &#8212; Thun 0.1.1 documentation</title>
+    <title>Python Module Index &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/search.html b/docs/sphinx_docs/_build/html/search.html
index 7bfcf57..778e8f5 100644
--- a/docs/sphinx_docs/_build/html/search.html
+++ b/docs/sphinx_docs/_build/html/search.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Search &#8212; Thun 0.1.1 documentation</title>
+    <title>Search &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/_build/html/searchindex.js b/docs/sphinx_docs/_build/html/searchindex.js
index fb36beb..cde5b78 100644
--- a/docs/sphinx_docs/_build/html/searchindex.js
+++ b/docs/sphinx_docs/_build/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["index","joy","lib","library","notebooks/Advent of Code 2017 December 1st","notebooks/Advent of Code 2017 December 2nd","notebooks/Advent of Code 2017 December 3rd","notebooks/Advent of Code 2017 December 4th","notebooks/Advent of Code 2017 December 5th","notebooks/Advent of Code 2017 December 6th","notebooks/Categorical","notebooks/Developing","notebooks/Generator Programs","notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators","notebooks/Intro","notebooks/Newton-Raphson","notebooks/NoUpdates","notebooks/Quadratic","notebooks/Replacing","notebooks/Trees","notebooks/Zipper","notebooks/index","parser","pretty","stack"],envversion:52,filenames:["index.rst","joy.rst","lib.rst","library.rst","notebooks/Advent of Code 2017 December 1st.rst","notebooks/Advent of Code 2017 December 2nd.rst","notebooks/Advent of Code 2017 December 3rd.rst","notebooks/Advent of Code 2017 December 4th.rst","notebooks/Advent of Code 2017 December 5th.rst","notebooks/Advent of Code 2017 December 6th.rst","notebooks/Categorical.rst","notebooks/Developing.rst","notebooks/Generator Programs.rst","notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.rst","notebooks/Intro.rst","notebooks/Newton-Raphson.rst","notebooks/NoUpdates.rst","notebooks/Quadratic.rst","notebooks/Replacing.rst","notebooks/Trees.rst","notebooks/Zipper.rst","notebooks/index.rst","parser.rst","pretty.rst","stack.rst"],objects:{"joy.joy":{joy:[1,1,1,""],repl:[1,1,1,""],run:[1,1,1,""]},"joy.library":{"void":[3,1,1,""],BinaryBuiltinWrapper:[3,1,1,""],DefinitionWrapper:[3,2,1,""],FunctionWrapper:[3,1,1,""],SimpleFunctionWrapper:[3,1,1,""],UnaryBuiltinWrapper:[3,1,1,""],add_aliases:[3,1,1,""],app1:[3,1,1,""],app2:[3,1,1,""],app3:[3,1,1,""],b:[3,1,1,""],branch:[3,1,1,""],choice:[3,1,1,""],clear:[3,1,1,""],concat:[3,1,1,""],cons:[3,1,1,""],dip:[3,1,1,""],dipd:[3,1,1,""],dipdd:[3,1,1,""],divmod_:[3,1,1,""],drop:[3,1,1,""],dup:[3,1,1,""],dupd:[3,1,1,""],dupdip:[3,1,1,""],first:[3,1,1,""],floor:[3,1,1,""],genrec:[3,1,1,""],getitem:[3,1,1,""],help_:[3,1,1,""],i:[3,1,1,""],id_:[3,1,1,""],ifte:[3,1,1,""],infra:[3,1,1,""],initialize:[3,1,1,""],inscribe:[3,1,1,""],loop:[3,1,1,""],map_:[3,1,1,""],max_:[3,1,1,""],min_:[3,1,1,""],over:[3,1,1,""],parse:[3,1,1,""],pm:[3,1,1,""],pop:[3,1,1,""],popd:[3,1,1,""],popdd:[3,1,1,""],popop:[3,1,1,""],pred:[3,1,1,""],remove:[3,1,1,""],rest:[3,1,1,""],reverse:[3,1,1,""],rolldown:[3,1,1,""],rollup:[3,1,1,""],select:[3,1,1,""],sharing:[3,1,1,""],shunt:[3,1,1,""],sort_:[3,1,1,""],sqrt:[3,1,1,""],stack_:[3,1,1,""],step:[3,1,1,""],succ:[3,1,1,""],sum_:[3,1,1,""],swaack:[3,1,1,""],swap:[3,1,1,""],take:[3,1,1,""],times:[3,1,1,""],tuck:[3,1,1,""],uncons:[3,1,1,""],unique:[3,1,1,""],unstack:[3,1,1,""],warranty:[3,1,1,""],words:[3,1,1,""],x:[3,1,1,""],zip_:[3,1,1,""]},"joy.library.DefinitionWrapper":{add_def:[3,3,1,""],add_definitions:[3,3,1,""],parse_definition:[3,3,1,""]},"joy.parser":{ParseError:[22,4,1,""],Symbol:[22,2,1,""],text_to_expression:[22,1,1,""]},"joy.utils":{pretty_print:[23,0,0,"-"],stack:[24,0,0,"-"]},"joy.utils.pretty_print":{TracePrinter:[23,2,1,""]},"joy.utils.pretty_print.TracePrinter":{go:[23,5,1,""],viewer:[23,5,1,""]},"joy.utils.stack":{expression_to_string:[24,1,1,""],iter_stack:[24,1,1,""],list_to_stack:[24,1,1,""],pick:[24,1,1,""],pushback:[24,1,1,""],stack_to_string:[24,1,1,""]},joy:{joy:[1,0,0,"-"],library:[3,0,0,"-"],parser:[22,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","classmethod","Python class method"],"4":["py","exception","Python exception"],"5":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:classmethod","4":"py:exception","5":"py:method"},terms:{"0b11100111011011":11,"10m":13,"10n":13,"4ac":17,"5bkei":19,"\u03b5":15,"abstract":[14,19],"boolean":[2,3,14,19],"break":[9,14],"byte":11,"case":[2,3,5,9,13,24],"class":[3,14,22,23,24],"default":[3,8,12,24],"export":[3,22],"final":[2,6,13],"float":[3,14,20,22],"function":[0,1,4,5,6,7,8,10,11,12,16,20,21,22,23,24],"g\u00e9rard":20,"import":[2,4,5,6,7,8,9,11,12,13,15,17,18,19,20],"int":[6,12,13,14,20,22,24],"long":21,"new":[2,3,6,12,13,14,15,16,18,19],"public":16,"return":[1,3,5,6,8,9,11,13,14,15,17,18,19,22,23,24],"short":17,"static":[2,16],"switch":2,"true":[2,3,5,6,11,13,19],"try":[6,12,13],"void":[0,3],"while":[3,6,8,9,14,19,22,24],Adding:[14,21],And:[4,6,11,12,13,15,19,20,24],But:[0,5,10,11,13,14,18,19],CPS:14,For:[2,3,4,5,6,7,8,12,13,19,21,24],Going:5,Has:3,Its:3,Not:6,One:[2,14],RHS:19,TOS:[2,3,13],That:[11,13,19],The:[0,1,2,3,4,5,6,7,8,10,12,15,16,17,20,21,22,24],Then:[2,3,5,8,17,19],There:[6,8,13,19,24],These:[21,24],Use:[3,13,15],Using:[6,13,15,19],With:[4,13,15],__str__:23,_within_b:15,_within_p:15,_within_r:15,aaa:7,abbrevi:19,abl:17,about:[0,6,8,14,19,20,24],abov:[0,6,11,15,17,19],abs:[6,15],absolut:[6,14],accept:[1,2,3,11,13,14,15,19,20],access:[6,8],accomplish:17,accordingli:19,accumul:11,across:[6,8],act:15,action:[14,20],actual:[2,6,11,14,19],adapt:21,add:[3,4,5,6,11,12,14,17,23],add_alias:3,add_def:3,add_definit:[3,8,13,19],add_if_match:4,add_valu:8,added:[10,19],adding:[6,16],addit:[0,2,3,8,11,13,14,19],admit:6,advantag:13,after:[4,6,8,11,12,14],afterward:14,again:[2,3,6,8,11,14,15,19],against:[5,6],aggreg:[3,20],aka:[14,20],albrecht:0,algebra:19,algorithm:14,alia:3,alias:[3,14],align:[14,23],all:[3,4,5,11,12,13,14,19,23],alloc:6,allow:[13,16,19],almost:19,along:[13,14,17],alphabet:3,alreadi:[6,15,18,20],also:[0,11,13,14,19,24],altern:[10,19],although:[4,10,19],altogeth:12,alwai:[6,11,13,16],amort:19,amount:6,analysi:[10,21],anamorph:14,ani:[8,10,11,14,16,19,20,22],annual:14,anonym:19,anoth:[4,13,19,24],answer:6,anyth:[2,3,14],aoc20017:5,aoc20173:6,aoc2017:[4,5,6,7,8,9],api:16,app1:3,app2:[3,5,14,17,18],app3:3,app:14,appear:[2,7,10,11,19],append:8,appli:[2,3,5,11,19],applic:12,approach:[11,17],approxim:21,archiv:0,aren:20,arg:[2,3],argument:[2,3,12,13,14,15,23,24],arithmet:2,ariti:2,around:[11,24],arrai:8,arrang:8,arriv:[12,19],articl:[0,10],ask:[6,10,12],aspect:[0,6],assembl:8,assert:[6,9],assign:24,associ:19,assum:[4,5,7,8,15],asterisk:19,attack:14,attempt:[0,1],attribut:3,automat:[10,13,21],avail:[0,7],averag:[14,18],avoid:19,awar:2,awkward:19,azur:21,back:[6,8,19],backward:[16,19],bag:14,banana:[13,19],bank:9,barb:13,base:[0,2,3,5,9,13,16],basic:[1,2,3,4,6,14,19],bear:8,beat:8,becaus:[2,3,4,5,6,8,13,14,19,20,24],becom:[4,17,19,24],been:[13,15,16,19,20],befor:[5,8,12,13,14,19],begin:[6,13,19],behavior:[16,19],behaviour:[0,1],behind:8,being:0,belong:8,below:[2,3,6,11,12,19,20],bespok:14,best:0,better:[6,11,12,19],between:[0,5,6,11],biannual:14,big:[6,8,19],binari:[0,12,14,19],binary_search_tre:19,binarybuiltinwrapp:3,bind:14,bingo:20,bit:[6,11,12,19],block:[9,11],bodi:[2,14,19],body_text:3,bool:[5,13],borrow:14,both:[2,6,8,11,13,14,17,18,19,24],bottom:12,boundari:6,bracket:[6,14,22],branch:[3,4,5,8,11,12,19],breakpoint:14,bring:[11,14],btree:21,buck:19,bug:[0,14],build:[13,14,19,20,24],built:[13,17],bundl:[2,3],burgeon:14,calcul:6,calculu:10,call:[2,13,14,15,16,17,19,23,24],caller:19,came:[8,19],can:[0,2,3,4,5,6,10,11,12,13,14,15,16,17,18,20,21,24],candid:5,captur:14,card:14,care:[6,11,24],carefulli:[19,20],carri:[4,6,13],cartesian:10,categor:[0,17,21],categori:10,ccc:10,ccon:19,ceil:6,certain:[14,24],certainli:19,chang:[2,6,8,16,19,20],charact:20,chat:14,chatter:0,cheat:9,check:[5,12,13],checksum:5,child0:19,childn:19,children:19,choic:[3,13],choos:[16,19],circuit:10,circular:[4,19],cite_not:19,classmethod:3,clear:[3,6,11,14],cleav:[4,5,7,14,17,18],close:[0,1,10],clunki:11,cmp:21,cmp_:19,code:[0,1,10,13,19],collaps:13,collect:[10,12,14],column:6,combin:[0,3,7,11,12,14,15,17,20,21],come:[6,8,14],command:[4,14,17,19],common:[2,11,13],compar:[6,10],comparison:0,compel:10,compil:[2,8,10,13,14,18],complet:10,complex:[3,20],compos:13,compound:19,comput:[2,5,6,8,10,11,14,17],con:[3,5,8,9,11,12,13,14,15,17,20,24],conal:10,concat:[3,4,12,13,14,19],concaten:0,concatin:[0,3,24],concis:6,concret:13,concurr:2,condit:[8,14],condition:5,confid:6,conflict:19,cons2:19,consecut:[12,21],consid:[8,11,12,13,19,20],consist:[2,6,14,19],constant:19,constitu:13,consum:[5,13],contain:[0,2,3,6,7,12,13,14],context:2,continu:[0,5,13,20],control:14,conveni:10,convert:[13,18,19,22,24],cook:13,cool:19,copi:[2,3,4,11,13,19,21],copyright:14,corner:6,correct:6,correctli:19,correspond:10,could:[2,6,8,10,11,13,14,16,19,20],count:[3,6,7,12],count_stat:9,counter:11,cours:[6,8,11,13,19],cover:6,cpu:6,crack:19,crap:21,crash:19,creat:[0,2,3,4,11,12,13,15,19],crude:[19,22],current:[2,3,8,13,14,20,23],custom:16,cycl:[11,12],cython:14,dai:[13,14],data:[2,3,6,21],datastructur:[0,2,13,20,22,24],datatyp:24,ddididi:20,deal:[0,4,19],debugg:13,decid:19,decor:3,decoupl:13,decreas:6,decrement:3,deduc:11,deeper:0,deepli:10,def:[3,6,8,9,13,14,17,18,19,24],defi:3,defin:[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,20],definit:[2,3,7,8,11,12,13,14,15,16,19,21],definitionwrapp:[3,8,13,19],deleg:14,delet:21,demonstr:[10,13],depend:[13,19],deposit:19,dequot:[4,13],deriv:[2,3,4,5,11,14,15,21],descend:5,describ:[3,10,13,19,22],descript:[11,14,19],design:[2,3,5,19],desir:[6,14,19],destruct:19,detail:[6,14,19],detect:[5,12,13,19],determin:[5,6],develop:[0,12,14,21],diagram:11,dialect:1,dict:[1,3],dictionari:[0,1,3,14,15,17,19,21],did:6,didn:13,differ:[0,5,7,10,11,13,15,17,19,24],differenti:10,dig:20,digit:[4,11],dimension:6,dinfrirst:14,dip:[3,5,6,8,9,11,12,13,14,15,17,18,19],dipd:[3,8,12,13,14,17,19,20],dipdd:[3,19],direco:[9,15],direct:14,directli:[6,11,19,24],disappear:2,discard:[3,12,13,15,19],discov:5,disenstacken:[14,19],disk:14,displac:2,distanc:6,distribut:9,ditch:19,div:[3,14],dive:19,divid:5,divis:[5,19],divisor:5,divmod:[3,5],divmod_:3,doc:[2,3,14],document:[21,22,24],doe:[0,1,5,6,8,10,13,14,21,23],doesn:[4,8,11,13,16,19,24],dog:19,doing:[6,10,11,13,14,20],domain:[6,10],don:[5,6,8,11,14,19],done:[2,11,12,14,16],doodl:6,door:14,dot:23,doubl:[11,14],down:[2,3,6,8,15,20],down_to_zero:14,downward:8,dozen:14,draft:[9,10,16],dream:14,drive:12,driven:[11,15],driver:12,drop:[3,4,19],dudipd:14,due:4,dummi:5,dup:[3,4,5,6,8,9,11,12,13,14,15,17,19,20,24],dupd:3,dupdip:[3,5,6,11,13,17,19],duplic:[3,7,13,19],durat:2,dure:[2,13],each:[2,3,4,5,6,8,10,11,13,14,18,19,23],easi:[0,6,19,20],easier:[3,4,19],easili:10,edit:21,effect:[2,3,14,20],effici:[6,8,18,20],either:[1,2,3,5,13,19],eleg:[8,14,17,19],element:[2,3],elliott:10,els:[2,3,4,5,8,9,13],embed:[10,19,20],empti:[3,5,14,24],encapsul:14,enclos:14,encod:[8,12],encount:8,end:[6,8,11,13,24],endless:12,enforc:[2,14],engend:14,enlarg:6,enough:[6,13,14,17,23],enstacken:[12,14],ensur:7,enter:14,entir:24,entri:[3,20,23],epsilon:15,equal:[11,24],equat:[6,14,15],ergo:[6,13,19],err:19,error:[6,14,22],escap:8,essai:0,etc:[3,6,20,22],euler:21,eval:0,evalu:[1,2,3,4,13,14,15,17,18,19],even:8,evenli:5,eventu:[6,17],everi:12,everyth:[3,19],evolv:16,exactli:13,exampl:[0,3,4,5,6,7,8,11,12,13,15,19,22,24],exce:12,except:[14,19,22],execut:[0,1,2,3,5,14,18,20,24],exist:10,exit:8,expect:[2,3,5,13,19,24],experi:14,experiment:6,explan:14,explor:14,express:[0,1,2,3,10,13,18,19,20,23,24],expression_to_str:24,extend:6,extra:[4,5,11],extrem:14,extrememli:14,facet:0,facil:14,fact:[19,22],factor:[2,11,14,21],fail:[2,3,5,19,22],fals:[2,3,5,9,11,13],far:[8,13,15,19],fascin:0,fast:6,faster:6,favorit:17,fear:19,feel:6,few:[6,11,14],fewer:[3,14],fib:12,fib_gen:12,figur:[2,3,6,19],filter:19,fin:11,find:[2,3,4,5,11,12,19,21],finder:15,fine:[0,11,19],finish:17,first:[3,4,5,6,8,9,12,13,14,15,17,18,19,20,21],fit:[11,14,17],five:[11,13,14],fix:[2,3],flag:5,flatten:[14,19],flexibl:19,floor:[3,6],floordiv:11,flow:14,follow:[0,2,3,5,8,13,14,15,16,20],foo:[14,16,19],foo_ii:16,form:[2,3,5,7,10,11,12,21,24],forman:14,format:[21,23],formula:[0,6,11,21],forth:[4,8,14,19],fortun:8,forum:0,forward:[5,8],found:[8,9,14,19],four:[2,3,6,8,11,12,14,19],fourteen:11,fourth:[2,3,4,19],fractal:14,fraction0:14,fraction:[2,14],framework:14,free:[10,14,19],freeli:[2,6],from:[0,1,2,3,4,5,6,7,8,9,11,12,14,15,17,18,19,20,21,24],front:[2,3],full:[7,11],fun:6,functionwrapp:[3,19],funtion:19,further:[15,21],futur:17,garbag:14,gari:19,gcd:14,gen:9,gener:[2,3,6,8,10,21,24],genrec:[3,5,8,13,14,19],geometr:11,geometri:19,get:[2,5,6,10,11,12,13,14,21],get_valu:8,getitem:3,getrecursionlimit:24,getsourc:14,ghc:10,give:[6,10,11,13,15,24],given:[2,3,4,5,6,8,9,11,12,15,20],glue:14,goal:8,going:[5,6,8,19,20],good:[8,11,19],grab:3,grammar:22,grand:14,graph:6,great:[0,4,6,14,21],greater:[6,24],grid:6,group:[0,6],gsra:15,guard:[5,6],had:[11,20],haiku:14,half:[11,20],half_of_s:4,halfwai:4,hand:[14,17,18,19,21],handi:15,handl:24,happen:[6,14,19],hard:20,hardli:13,hardwar:10,has:[0,2,5,6,8,12,13,14,15,16,19,20,24],haskel:10,have:[2,3,4,5,6,8,9,11,12,13,14,15,16,19,20,21,24],head:[5,13,24],help:[7,13,14,19],help_:3,helper:[3,5],herd:14,here:[6,11,12,13,17,19,20],heterogen:19,heurist:[4,8],hide:19,higher:[14,19],highest:[5,19],highli:[14,19],hindsight:5,histori:23,hmm:19,hog:19,hoist:3,hold:11,hood:8,hope:[0,11,14,21],host:21,how:[0,6,7,8,10,13,19,20],html:[2,3,12,17,21],http:19,huet:20,hugh:[15,19],human:14,hypothet:2,id_:3,idea:[10,11,14,19],ident:[3,13],identifi:6,ift:[3,4,5,8,13,19],ignor:[3,19],illustr:13,imagin:20,immedi:[8,13],immut:[14,19],imper:13,implement:[0,1,2,3,6,9,10,13,14,16,17,19],impli:5,implicit:14,includ:[7,10],inclus:11,incom:24,incompat:16,incr_at:8,incr_step_count:8,incr_valu:8,increas:[6,8,11],increment:[3,10,11,16],index:[0,6,9,14,24],index_of:9,indexerror:24,indic:19,infil:19,infinit:6,inform:3,infra:[3,12,13,14,17,18],infrastructur:3,init:8,init_print:6,initi:[2,3,5,6,7,8,14,15,19],inlin:19,inner:5,input:[1,4,5,6,7,13,15],inscrib:3,inspect:14,instal:0,instanti:[10,23],instead:[6,11,12,13,19,20,24],instruct:8,integ:[2,3,4,5,6,7,8,12,13,14],integr:3,intend:[0,14],interact:[14,21],interest:[0,6,11,12,19],interlock:6,interlud:21,intermedi:13,intern:[0,23,24],interpret:[0,10,13,16,22,23],interrupt:14,interv:[10,11],introduc:16,introduct:0,invari:3,invers:3,investig:17,ipf:14,ipynb:12,isn:[13,20],item:[2,3,4,5,9,13,14,19,24],iter:[1,3,6,13,14,21,24],iter_stack:[9,18,24],its:[0,2,3,5,6,10,11,13,14,19,24],itself:[0,2,8,14,19],j05cmp:[2,3],jenni:19,job:[8,21],john:[15,19],joi:[2,4,5,7,8,9,10,15,16,17,18,19],joypi:[8,9,13,14,19,20],jump:8,jupyt:21,just:[0,2,3,4,5,6,8,12,13,14,16,20],keep:20,kei:21,kevin:0,key_n:19,keyerror:19,kind:[2,6,8,10,13,14,19],kleen:19,know:[6,11,13,19],known:10,labda:10,lambda:[10,13],lambdifi:6,languag:[10,14,16,17,19],larg:6,larger:[6,24],largest:[3,5,8],last:[4,8,11,13],lastli:[12,13],later:[8,14],law:2,lazi:15,lazili:15,lcm:11,lead:[8,14],leaf:19,lean:14,learn:[0,9],least:[2,6,8,11,13,24],least_fract:14,leav:[5,6,8,11,12,19],left:[6,12,13,14,20,23,24],leftov:13,legendari:8,legibl:8,len:9,length:[3,11,24],lens:13,less:[11,12,13,14,24],lesser:6,let:[4,5,6,8,12,13,15,17,19,20],level:[10,19],librari:[0,6,8,9,15,17,18,19],lieu:19,like:[2,3,5,6,9,11,13,14,15,17,22],line:[3,5,8,13,14,19,23],linear:24,link:0,linux:0,list:[0,3,4,5,7,8,9,11,14,15,20,21,23],list_to_stack:[8,9,24],liter:[1,19,20,22],littl:[6,8,19,21],live:21,lkei:19,load:[11,14],locat:[2,6],locu:23,log_2:19,logic:[0,11],longer:19,look:[6,12,14,15,19],lookup:[14,19],loop:[0,1,3,11],lot:[14,17,19,20],love:11,low:10,lower:[11,19],lowest:[5,19],machin:[0,19],machineri:19,macro:14,made:[0,5,14,19,20],mai:[2,8,13,19],mail:0,main:[0,3,4,14,20],mainloop:16,maintain:20,major:16,make:[2,3,4,10,11,13,14,18,20],make_distributor:9,make_gener:15,manfr:[0,2,3,10],manhattan:6,mani:[0,6,7,8,12,13,14],manipul:6,manual:[6,13],map:[1,3,11,13,14,16,17,19],map_:3,mark:[6,8],marker:14,mask:[11,12],match:[0,1,4],materi:0,math:[0,6,8,14,19],mathemat:[6,14],matter:[4,11,13,15,19],max:[5,6,9],max_:3,maximum:[3,19],maxmin:5,mayb:[13,19],maze:8,mean:[5,10,11,13,14,15,19,24],meant:[13,14,17,19],meantim:8,mem:8,member:[2,3,6],memori:6,mental:14,mention:2,mercuri:0,merg:19,meta:[14,19],methink:19,method:[0,3,6,14,21,23],mfloor:6,midpoint:11,might:[4,10,12,13,19],million:12,min:5,min_:3,mind:8,minimum:3,minu:[3,17],mirror:0,miscellan:[0,21],mistak:9,mix:14,mnemon:4,mod:3,model:[10,14],modern:0,modif:12,modifi:[8,14,20],modul:[0,1,3,14,22],modulu:14,monkei:6,month:14,more:[0,3,7,8,10,11,12,13,14,15,17,18,19,22,24],most:19,mostli:0,move:[4,6,8],movement:2,mrank_of:6,much:[6,8,11,13,19],muck:19,mul:[14,17,20,23],multi:3,multipl:[13,21],must:[2,3,5,6,7,11,13,16],mutabl:8,n_rang:12,nail:8,name:[1,3,4,14,16,20,21,22,24],natur:[11,12,19],navig:20,need:[2,3,4,5,6,8,9,11,12,13,15,16,19],neg:[3,8,17],nest:[14,19,20],network:14,never:16,newton:[0,21],next:[4,5,6,8,11,13,19],nice:[0,4,6,13,24],niether:2,node:21,node_kei:19,node_valu:19,non:[5,19],none:[1,3],normal:[7,13],notat:[14,19],note:[2,6,11,15,19,24],notebook:[11,14,20,21],notebook_preambl:[2,4,5,6,7,8,9,11,12,13,15,17,18,19,20],noth:[2,19],notic:11,now:[4,5,6,11,12,13,14,18,21],nth:[3,24],nullari:[5,8,9,14,19],number:[1,2,3,5,11,12,24],object:22,observ:11,obviou:12,obvious:[5,7,8],occur:19,odd:[11,12],off:[2,3,6,11,12,20],offset:8,offset_of:6,old:[2,18],omit:13,onc:[3,7,16,17,19],one:[2,3,4,5,6,7,8,11,12,13,17,19,23,24],ones:12,onli:[2,3,4,5,6,8,11,13,19,20,24],onto:[1,2,3,14,24],open:[7,14],oper:[3,5,13,14,19,24],oppos:4,option:[1,14,19,24],order:[2,3,4,5,13,14,21,24],org:[0,19],origin:[0,1,2,3,4,19,20],other:[0,2,3,5,6,10,13,14,19,24],otherwis:[3,5,11,12,19],our:[4,5,6,11,12,13,14,15],ourselv:13,out:[2,3,6,10,11,12,13,14,19,20],outcom:19,output:[6,13,15],outsid:[8,10],outward:6,over:[3,4,6,10,11,12,14,15,17,19,21],overhead:6,overkil:13,overshadow:6,own:[6,19],pack:[19,24],packag:[0,14],page:[0,17,19,24],pair:[2,3,4,5,11,12],pair_up:4,palidrom:11,palindrom:11,pam:[14,17],paper:[6,10,13,14,19,20],parallel:2,paramet:[1,2,3,8,13,22,23,24],paranthes:19,parenthes:[8,19,24],pariti:12,pars:[0,3,14,19],parse_definit:3,parseerror:22,parser:0,part:[2,3,5,8,13,15,17,19],partial:[6,13],particular:20,particularli:8,pass:[0,19,23],passphras:7,path:6,pattern:[6,11,19],payoff:13,pe1:[11,12],pe2:12,pearl:20,pend:[3,13,14,20,23],peopl:21,per:[6,14],perform:8,perhap:12,period:14,permit:[8,24],persist:19,phase:2,pick:[11,12,24],pickl:14,pictur:19,piec:13,pip:0,pita:9,place:[3,6,8,11,13,14],plai:0,plain:8,plane:6,plu:[3,6,17],plug:[12,13,19],point:[6,10,13,14,19],pointless:2,pop:[3,4,5,8,9,11,12,13,14,17,18,19,24],popd:[3,8,14,15,18],popdd:[3,5,12,17],popop:[3,4,5,8,9,11,12,13,14,15,19],port:6,posit:[3,8,11,13,14],possibilit:19,possibl:[5,19,21],post:[14,19],potenti:3,power:14,pragmat:11,pre:[8,13,19],preambl:15,precis:[0,1],pred:3,predic:[2,5,12,13],prefer:13,prefix:[13,23],prep:[5,19],prepar:[8,13],preprocessor:13,present:19,preserv:10,pretti:[6,17,19,23,24],pretty_print:0,prevent:13,previou:[6,8,14],prime:[5,15],primit:[2,3,8,17],primrec:[3,5,8,9,12,13,14,15],print:[0,1,2,3,6,13,23,24],probabl:[4,12,14,19],problem:[6,14,21],proc_curr:19,proc_left:19,proc_right:19,proce:[4,11],process:[8,13,14,23],processor:19,produc:[4,11,13,19],product:14,program:[0,2,3,4,5,6,8,12,14,15,20],project:21,prompt:14,proper:[2,3],properli:8,properti:0,provid:[0,3,10,14],prune:19,pun:[0,14],pure:[0,19],puriti:14,purpos:14,push:[2,3,13,14,20,24],pushback:[14,19,24],put:[1,2,12,14,24],puzzl:[4,5,6,7],pypi:0,pyramid:6,python:[0,2,3,6,8,13,17,19,20,21,22,24],quadrat:[0,6,21],queri:19,queu:13,quit:[0,1,6],quot:[0,3,12,13,14,15,17,19,20,23],quotat:[2,3],quotient:3,rais:[19,22,24],random:8,rang:[6,13,14],range_sum:13,range_to_zero:14,rank_and_offset:6,rank_of:6,raphson:15,rather:[11,13,14,19],ratio:14,reach:[8,11,12,13],read:[0,1,11,12,19,20],readabl:18,real:19,realiz:[4,8,10,19],realli:6,rearrang:[2,13],reason:[6,11,14],rebuild:20,rec1:[2,3],rec2:[2,3],recogn:22,record:[14,23],recur:13,recurs:[2,3,5,8,9,12,14,15,21,24],recus:14,recusr:19,redistribut:[3,14],reduc:2,redund:24,reexamin:19,refactor:[13,14,16],refer:[0,2],regist:2,regular:22,rel:[8,17],releas:16,relev:6,remain:[2,3,14,16],remaind:[3,15],remind:13,remov:[3,6,19,24],renam:19,render:[19,21],repeat:[4,6,11],repeatedli:11,repl:[0,1],replac:[0,2,3,12,13,19,20,21,24],repositori:0,repres:[2,14,19,22,23],represent:24,reprod:12,request:6,requir:[6,24],resembl:14,respect:11,rest:[3,5,9,11,12,14,19,20,21,24],restor:2,result:[1,2,3,5,11,12,13,17,19,20],resum:14,retir:2,retri:14,reus:19,revers:[3,4,5,11,12,13,20,24],rewrit:[8,14],rewritten:14,richard:19,rid:19,right:[6,12,13,14,23,24],rightmost:11,rkei:19,role:19,roll:[3,5,7,8,13,15,17,19],rolldown:3,rollup:3,root:[3,6,17,21],rotate_seq:4,round:4,row:[5,6],row_valu:6,run:[0,1,3,6,11,13,14,15,19,20],runtim:6,runtimeerror:24,sai:19,same:[2,10,11,13,19,24],sandwich:[2,3],save:[2,11,14],scan:3,scanner:[14,22],scenario:20,scheme:[17,19],scope:[4,19],search:[0,6,19],second:[3,4,5,13,14,19,24],secur:7,see:[0,6,12,13,14,16,18,19,20,23],seem:[0,9,11,14,19],seen:20,select:[3,6],semant:[2,3,14,16,19],semi:14,send:14,sens:[0,2,11,20],separ:14,sequenc:[0,1,2,3,4,5,7,8,9,11,14,18,19,20,22],seri:[6,11,12,13,19,20],serv:13,set:[2,3,13],seven:[11,12],sever:[0,10,14],share:[3,6,14],shelf:2,shift:[11,12],shine:8,shorter:21,shortest:6,should:[2,5,11,13,19],shouldn:14,show:[6,10,19,20],shunt:[3,20],side:19,sign:6,signal:5,signifi:[14,19],silli:19,similar:19,simon:14,simpl:[6,13,14,24],simplefunctionwrapp:[3,8,9,17,18],simplest:21,simpli:10,simplifi:[6,11,19,20],sinc:[2,6,11,17,19],singl:[3,12,14,18,22],situ:19,situat:19,six:[11,12,14],sixti:[11,12],size:[4,7,8,9,14,21],skeptic:14,skip:[6,8],slight:15,slightli:[13,19],small:[4,19],smallest:[3,5],smart:[8,13],sneaki:6,softwar:14,solei:2,solut:[6,11],solv:6,solvabl:14,some:[2,3,5,6,8,12,13,14,19,21,24],somehow:19,someth:[2,4,8,16],sometim:19,somewher:[13,19,21],sophist:6,sort:[3,5,13,17,19],sort_:3,sourc:[0,1,3,22,23,24],space:[6,11,23],span:11,special:[12,13,19],specif:[0,10],speed:[6,8,18],sphinx:[21,24],spiral:6,spirit:[0,1,19],split_at:4,spreadsheet:5,sqr:[14,17,20],sqrt:[3,6,15,17],squar:[3,6,21,22],stack:[0,1,3,5,8,9,11,12,13,15,17,18,19,20,22,23],stack_:3,stack_to_str:24,stage:19,stai:[0,1],stand:10,standard:14,star:19,stare:19,start:[5,6,8,9,11,12,13,14,15,17,19],state:[5,8,14],step:[3,4,5,6,7,11,14,17,18,19,20],step_zero:[4,5,7],still:[6,8,13],stop:19,storag:[11,13,19],store:[6,11,13],stori:13,str:[1,22,23,24],straightforward:[1,4,6,12],strang:8,stream:[11,15],string:[1,2,3,4,14,20,22,23,24],strip:6,structur:[13,14,19,20,24],stuff:19,style:[0,10],sub:[16,19],subclass:14,subject:20,subract:6,substitut:[6,13],subtract:[5,6,11],succ:3,success:15,suffici:[8,13],suggest:[5,10,19],suitabl:[3,10,11],sum:[3,4,5,12,13,14,17,18,19],sum_:3,summand:11,suppli:[13,19,22],support:[6,14,23,24],sure:[6,13],suspect:2,swaack:[3,13,17,18,19,20],swap:[3,4,5,6,7,9,11,12,13,14,15,18,19,20],swon:[3,9,12,13,14,19,20],swoncat:[8,9,12,13,14,15,19],symbol:[2,3,6,17,20,22],symmetr:[11,19],sympi:17,syntact:14,syntax:[14,24],sys:[6,24],system:[6,7,14,19],tail:[5,19,24],take:[3,4,6,8,11,12,14,15,17,19,24],taken:8,talk:[14,19,24],target:[6,20],task:6,tast:10,tbd:14,technic:2,techniqu:[10,20],technolog:2,teh:19,temporari:20,ten:11,term:[1,2,5,8,9,13,14,15,22,24],termin:[2,3,5],ternari:14,test:[2,3],text:[0,1,3],text_to_express:[14,22],textual:14,than:[0,3,6,7,11,12,14,15,17,24],thei:[2,5,6,11,12,13,14,19,20,22,24],them:[2,3,5,6,11,12,13,19,20,21],theori:[2,3],therefor:[12,19],thi:[0,1,2,3,4,5,6,8,9,10,11,12,13,14,17,20,22,23,24],thing:[2,5,6,8,12,13,17,19,20,22,24],think:[2,8,11,13,14,19],third:[3,4,5,12,14,19],thirti:11,those:[2,3,5,6,8,13,19,21],though:[11,12,19],thought:14,thousand:11,thread:2,three:[2,3,8,11,14,19],through:[1,11,14,20,24],thu:4,thun:[2,3,10,16],thunder:14,tied:19,tile:6,time:[3,6,8,9,11,13,14,19,20],tini:19,to_set:19,todai:14,todo:[14,21,22],togeth:[12,14],token:22,toler:21,tommi:19,too:[13,19],took:6,tool:14,top:[2,3,14,23,24],total:[4,6,11],total_match:4,trace:[0,14,17,20,21,24],traceprint:23,track:20,tracker:0,trade:6,transform:[10,13],translat:[6,10,13],travers:[20,21],treasur:0,treat:[0,2,3,21],treatment:12,tree:[0,14,21],treemap:13,tri:11,trick:[11,19],tricki:[6,8],trivial:[5,8,19],trobe:0,trove:0,truediv:17,truthi:[3,14],ts0:[13,19],ts1:[13,19],tuck:[3,5,14,19],tupl:[3,14,24],turn:[2,3,6],twice:[6,13,19],two:[2,3,5,6,11,13,14,15,19,20,24],type:[1,10,13,14,21,22,23,24],typic:[2,3],unari:[8,13,14],unarybuiltinwrapp:3,unbalanc:[19,22],uncon:[3,4,5,12,13,14,19,20],under:[2,3,8,14],understand:[0,6,19],undocu:14,unfortun:24,uniqu:[3,7,19],unit:[4,13,14,19],univers:[0,14],unless:[6,13],unlik:13,unnecessari:21,unpack:[2,3,24],unpair:11,unquot:[13,14,19],unstack:3,untangl:[12,13],until:[5,6,8,12],unus:11,unusu:19,updat:[0,21],upward:8,usag:14,use:[0,2,3,6,8,10,11,12,14,15,16,17,18,19,20,24],used:[3,10,13,14,19,20,22,24],useful:0,user:6,uses:[2,5,11,13],using:[3,5,6,12,13,17,19,20],usual:[0,2],util:[0,8,9,18,19],valid:7,valu:[2,3,5,6,11,13,14,15,18,21,24],value_n:19,valueerror:24,vanilla:8,variabl:[13,21],variat:13,varient:19,varieti:[10,14],variou:0,vener:24,verbos:10,veri:[0,1,6,10,14,19,24],versa:2,version:[0,1,2,12,16,17,20,21],via:14,vice:2,view:21,viewer:[1,14,16,23],von:[0,2,3,10],wai:[0,2,3,4,6,8,10,11,13,14,19],walk:19,wall:6,want:[2,6,8,11,12,15,19],warranti:[3,14],wash:14,wast:14,web:24,websit:[0,11],welcom:14,well:[0,4,5,6,10,14,19,22],were:[6,8,13,14,20],what:[2,3,5,8,9,10,13,14,17,19,23],whatev:[2,3,12,19,24],when:[11,12,13,14,15,19,20,22,24],where:[2,3,4,5,8,13,14,19,21,24],whether:13,which:[0,1,3,5,6,8,11,13,14,15,17,19,20,24],whole:[2,3,5,11,19],whose:12,why:[6,15,19],wiki:19,wikipedia:[0,19,20],wildli:14,wind:14,winner:6,wire:13,wit:8,within:[14,19,21],without:[2,14,19],won:[19,24],word:[0,3,4,5,7,11,12,14,19,20],work:[0,4,5,6,8,11,12,13,14,19,20,24],worth:[6,11],would:[2,5,6,7,8,9,11,12,13,14,15,19,20,24],wouldn:8,wrap:[3,6,14],write:[4,6,8,10,12,13,15,19,20,21,24],written:[0,1,8,15,17,18,24],wrong:2,wtf:13,wtfmorphism:13,year:14,yet:[8,13,19,20],yield:[2,3,24],you:[0,2,3,5,6,8,11,12,13,14,16,18,19,20,23,24],your:[2,3,4,5,6,7,14],yourself:[14,19],zero:[3,5,6,8,13,19,22,24],zip:[4,11],zip_:3,zstr:20},titles:["Thun 0.1.1 Documentation","Joy Interpreter","Functions Grouped by, er, Function with Examples","Function Reference","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Categorical Programming","Developing a Program in Joy","Using <code class=\"docutils literal notranslate\"><span class=\"pre\">x</span></code> to Generate Values","Hylomorphism","Thun: Joy in Python","Newton\u2019s method","No Updates","Quadratic formula","Replacing Functions in the Dictionary","Treating Trees","Preamble","Essays about Programming in Joy","Parsing Text into Joy Expressions","Tracing Joy Execution","Stack or Quote or Sequence or List\u2026"],titleterms:{"1st":4,"2nd":5,"3rd":6,"4th":7,"5th":8,"6th":9,"case":[15,19],"final":5,"function":[2,3,9,13,14,15,17,18,19],"long":18,"void":2,"while":2,Adding:19,One:12,The:[11,13,14,19],There:14,Use:19,Using:12,about:21,abov:13,add:[2,8,19],adding:19,address:20,advent:[4,5,6,7,8,9],all:[6,8],ana:13,analysi:[6,11],anamorph:[2,13],app1:2,app2:2,app3:2,appendix:13,approxim:15,automat:19,averag:2,base:[15,19],befor:9,better:13,binari:2,block:5,branch:2,breakdown:8,btree:19,can:19,cata:13,catamorph:13,categor:10,chatter:2,check:17,child:19,choic:2,cleanup:17,clear:2,cleav:2,cmp:19,code:[4,5,6,7,8,9,14],combin:[2,13,19],compar:19,comparison:2,compil:12,comput:15,con:[2,19],concat:2,consecut:15,continu:14,count:[8,9],crap:19,current:19,data:19,datastructur:[14,19],decemb:[4,5,6,7,8,9],defin:[17,19],definit:17,delet:19,deriv:[13,17,19],determin:20,develop:11,dialect:0,dictionari:18,dip:[2,20],dipd:2,dipdd:2,direco:12,disenstacken:2,div:2,document:0,doe:19,down:5,down_to_zero:2,drive:9,drop:2,dup:2,dupd:2,dupdip:2,els:19,empti:19,enstacken:2,equal:19,essai:21,euler:[11,12],eval:14,even:12,exampl:[2,14],execut:23,express:[14,22],extract:[13,19],factor:[13,19],factori:13,fibonacci:12,filter:11,find:[6,13,15],first:[2,11],five:12,flatten:2,floordiv:2,form:[13,19],formula:17,four:13,from:13,ftw:4,fun:13,further:11,fusion:13,gcd:2,gener:[9,11,12,13,15,19],genrec:2,get:[8,19],getitem:2,given:[13,19],gotten:8,greater:19,group:2,help:2,host:0,how:[9,11,12],hylo:13,hylomorph:13,ift:2,increment:8,index:8,indic:0,inform:0,infra:[2,19,20],integ:11,interlud:19,intern:22,interpret:[1,14],isn:19,item:20,iter:[11,19],joi:[0,1,3,6,11,13,14,20,21,22,23,24],just:[11,19],kei:19,languag:0,law:13,least_fract:2,left:19,less:19,let:11,librari:[3,14],like:19,list:[2,13,19,24],literari:14,littl:11,logic:2,loop:[2,5,14],lshift:2,make:[15,19],mani:[9,11],map:2,math:2,method:15,min:2,miscellan:[2,19],mod:2,modif:19,modulu:2,mul:2,multipl:[11,12],must:19,name:[17,19],nativ:17,neg:2,newton:15,next:15,node:[13,19],now:[8,19],nullari:2,number:[6,13],offset:6,one:14,onli:14,order:19,osdn:0,our:19,out:5,over:2,pack:11,pam:2,paper:5,para:13,paramet:19,parameter:[13,19],paramorph:13,pars:[2,22],parser:[14,22],pass:14,path:20,pattern:13,per:19,piec:5,pop:2,popd:2,popop:2,pow:2,power:12,preambl:[8,13,20],pred:2,predic:[8,11,15,19],pretty_print:23,primrec:2,print:14,problem:[11,12],process:19,product:2,program:[9,10,11,13,17,19,21],project:[0,11,12],pure:14,put:[6,19],python:[14,18],quadrat:17,quick:0,quot:[2,24],rang:[2,11],range_to_zero:2,rank:6,read:14,recal:9,recur:[15,19],recurs:[13,19],redefin:19,refactor:[4,11,19],refer:3,regular:14,rem:2,remaind:2,remov:2,render:11,repeat:9,repl:14,replac:18,rescu:6,reset:12,rest:[2,13],revers:2,right:[19,20],roll:2,rolldown:2,rollup:2,root:15,rshift:2,run:[2,12],sat:5,second:2,select:2,sequenc:[12,24],set:[8,15,19],shorter:18,should:14,shunt:2,simplest:11,simplifi:17,size:[2,18],slight:19,sqr:2,sqrt:2,squar:15,stack:[2,14,24],start:0,state:9,step:[2,8,13],style:14,sub:2,succ:2,sum:[2,11],swaack:2,swap:2,swon:2,swoncat:2,symbol:[13,14],sympi:6,tabl:0,tail:13,take:2,term:[11,12,19],ternari:2,text:22,than:[13,19],thi:19,think:5,third:2,three:12,thun:[0,14],time:[2,12],todo:19,togeth:[6,8,19],toi:19,token:14,toler:15,trace:[18,23],traceprint:14,travers:19,treat:19,tree:[13,19,20],treestep:[13,19],triangular:13,tricki:5,truediv:2,truthi:2,tuck:2,two:12,type:19,unari:2,uncon:2,unfinish:13,unit:2,unnecessari:11,unquot:2,unstack:2,updat:16,use:13,usual:13,util:[23,24],valu:[8,12,19],variabl:17,version:[6,11,18,19],view:14,want:5,within:15,word:2,write:17,xor:2,zero:12,zip:2,zipper:20}})
\ No newline at end of file
+Search.setIndex({docnames:["index","joy","lib","library","notebooks/Advent of Code 2017 December 1st","notebooks/Advent of Code 2017 December 2nd","notebooks/Advent of Code 2017 December 3rd","notebooks/Advent of Code 2017 December 4th","notebooks/Advent of Code 2017 December 5th","notebooks/Advent of Code 2017 December 6th","notebooks/Categorical","notebooks/Developing","notebooks/Generator Programs","notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators","notebooks/Intro","notebooks/Newton-Raphson","notebooks/NoUpdates","notebooks/Ordered_Binary_Trees","notebooks/Quadratic","notebooks/Replacing","notebooks/Trees","notebooks/Treestep","notebooks/Zipper","notebooks/index","parser","pretty","stack"],envversion:52,filenames:["index.rst","joy.rst","lib.rst","library.rst","notebooks/Advent of Code 2017 December 1st.rst","notebooks/Advent of Code 2017 December 2nd.rst","notebooks/Advent of Code 2017 December 3rd.rst","notebooks/Advent of Code 2017 December 4th.rst","notebooks/Advent of Code 2017 December 5th.rst","notebooks/Advent of Code 2017 December 6th.rst","notebooks/Categorical.rst","notebooks/Developing.rst","notebooks/Generator Programs.rst","notebooks/Hylo-, Ana-, Cata-, and Para-morphisms - Recursion Combinators.rst","notebooks/Intro.rst","notebooks/Newton-Raphson.rst","notebooks/NoUpdates.rst","notebooks/Ordered_Binary_Trees.rst","notebooks/Quadratic.rst","notebooks/Replacing.rst","notebooks/Trees.rst","notebooks/Treestep.rst","notebooks/Zipper.rst","notebooks/index.rst","parser.rst","pretty.rst","stack.rst"],objects:{"joy.joy":{joy:[1,1,1,""],repl:[1,1,1,""],run:[1,1,1,""]},"joy.library":{"void":[3,1,1,""],BinaryBuiltinWrapper:[3,1,1,""],DefinitionWrapper:[3,2,1,""],FunctionWrapper:[3,1,1,""],SimpleFunctionWrapper:[3,1,1,""],UnaryBuiltinWrapper:[3,1,1,""],add_aliases:[3,1,1,""],app1:[3,1,1,""],app2:[3,1,1,""],app3:[3,1,1,""],b:[3,1,1,""],branch:[3,1,1,""],choice:[3,1,1,""],clear:[3,1,1,""],cmp_:[3,1,1,""],concat:[3,1,1,""],cond:[3,1,1,""],cons:[3,1,1,""],dip:[3,1,1,""],dipd:[3,1,1,""],dipdd:[3,1,1,""],divmod_:[3,1,1,""],drop:[3,1,1,""],dup:[3,1,1,""],dupd:[3,1,1,""],dupdip:[3,1,1,""],first:[3,1,1,""],floor:[3,1,1,""],genrec:[3,1,1,""],getitem:[3,1,1,""],help_:[3,1,1,""],i:[3,1,1,""],id_:[3,1,1,""],ifte:[3,1,1,""],infra:[3,1,1,""],initialize:[3,1,1,""],inscribe:[3,1,1,""],loop:[3,1,1,""],map_:[3,1,1,""],max_:[3,1,1,""],min_:[3,1,1,""],over:[3,1,1,""],parse:[3,1,1,""],pm:[3,1,1,""],pop:[3,1,1,""],popd:[3,1,1,""],popdd:[3,1,1,""],popop:[3,1,1,""],pred:[3,1,1,""],remove:[3,1,1,""],rest:[3,1,1,""],reverse:[3,1,1,""],rolldown:[3,1,1,""],rollup:[3,1,1,""],select:[3,1,1,""],sharing:[3,1,1,""],shunt:[3,1,1,""],sort_:[3,1,1,""],sqrt:[3,1,1,""],stack_:[3,1,1,""],step:[3,1,1,""],succ:[3,1,1,""],sum_:[3,1,1,""],swaack:[3,1,1,""],swap:[3,1,1,""],take:[3,1,1,""],times:[3,1,1,""],tuck:[3,1,1,""],uncons:[3,1,1,""],unique:[3,1,1,""],unstack:[3,1,1,""],warranty:[3,1,1,""],words:[3,1,1,""],x:[3,1,1,""],zip_:[3,1,1,""]},"joy.library.DefinitionWrapper":{add_def:[3,3,1,""],add_definitions:[3,3,1,""],parse_definition:[3,3,1,""]},"joy.parser":{ParseError:[24,4,1,""],Symbol:[24,2,1,""],text_to_expression:[24,1,1,""]},"joy.utils":{pretty_print:[25,0,0,"-"],stack:[26,0,0,"-"]},"joy.utils.pretty_print":{TracePrinter:[25,2,1,""]},"joy.utils.pretty_print.TracePrinter":{go:[25,5,1,""],viewer:[25,5,1,""]},"joy.utils.stack":{expression_to_string:[26,1,1,""],iter_stack:[26,1,1,""],list_to_stack:[26,1,1,""],pick:[26,1,1,""],pushback:[26,1,1,""],stack_to_string:[26,1,1,""]},joy:{joy:[1,0,0,"-"],library:[3,0,0,"-"],parser:[24,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","classmethod","Python class method"],"4":["py","exception","Python exception"],"5":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:classmethod","4":"py:exception","5":"py:method"},terms:{"0b11100111011011":11,"10m":13,"10n":13,"4ac":18,"5bkei":[17,20],"\u03b5":15,"abstract":[14,17,20],"boolean":[2,3,14,17,20],"break":[9,14],"byte":11,"case":[2,3,5,9,13,21,26],"class":[3,14,24,25,26],"default":[3,8,12,17,26],"export":[3,24],"final":[2,6,13,17],"float":[3,14,22,24],"function":[0,1,4,5,6,7,8,10,11,12,16,22,23,24,25,26],"g\u00e9rard":22,"import":[2,4,5,6,7,8,9,11,12,13,15,17,18,19,20,21,22],"int":[6,12,13,14,22,24,26],"long":[17,23],"new":[2,3,6,12,13,14,15,16,19,20],"public":16,"return":[1,3,5,6,8,9,11,13,14,15,17,18,19,20,21,24,25,26],"short":18,"static":[2,16],"switch":2,"throw":17,"true":[2,3,5,6,11,13,20],"try":[6,12,13,21],"void":[0,3],"while":[3,6,8,9,14,17,20,24,26],Adding:[14,23],And:[4,6,11,12,13,15,17,20,22,26],But:[0,5,10,11,13,14,17,19,20],CPS:14,For:[2,3,4,5,6,7,8,12,13,17,20,23,26],Going:5,Has:3,Its:3,Not:6,One:[2,14],RHS:20,TOS:[2,3,13],That:[11,13,17,20],The:[0,1,2,3,4,5,6,7,8,10,12,15,16,18,22,23,24,26],Then:[2,3,5,8,17,18,20],There:[6,8,13,20,21,26],These:[23,26],Use:[3,13,15],Using:[6,13,15,17,20],With:[4,13,15,23],__str__:25,_tree_add_:17,_tree_add_e:17,_tree_add_p:17,_tree_add_r:17,_tree_add_t:17,_tree_delete_:17,_tree_delete_clear_stuff:17,_tree_delete_del:17,_tree_delete_r0:17,_tree_delete_r1:17,_tree_delete_rightmost:17,_tree_delete_w:17,_tree_get_:17,_tree_get_p:17,_tree_get_r:17,_tree_get_t:17,_tree_iter_order_curr:17,_tree_iter_order_left:17,_tree_iter_order_r:17,_tree_iter_order_right:17,_tree_t:17,_treestep_0:21,_treestep_1:21,_within_b:15,_within_p:15,_within_r:15,aaa:7,abbrevi:[20,21],abl:18,about:[0,6,8,14,17,20,22,26],abov:[0,6,11,15,17,18,20],abs:[6,15],absolut:[6,14],accept:[1,2,3,11,13,14,15,17,20,21,22],access:[6,8],accomplish:18,accordingli:[17,20],accumul:11,across:[6,8],act:15,action:[14,22],actual:[2,6,11,14,17,20],adapt:23,add:[3,4,5,6,11,12,14,18,25],add_alias:3,add_def:3,add_definit:[3,8,13,17,20,21],add_if_match:4,add_valu:8,added:[10,17,20],adding:[6,16],addit:[0,2,3,8,11,13,14,20,21],adjust:17,admit:6,advantag:13,after:[4,6,8,11,12,14],afterward:14,again:[2,3,6,8,11,14,15,17,20],against:[5,6],aggreg:[3,22],aka:[14,22],albrecht:0,algebra:20,algorithm:14,alia:3,alias:[3,14],align:[14,25],all:[3,4,5,11,12,13,14,17,20,21,25],alloc:6,allow:[13,16,17,20],almost:[17,20],along:[13,14,18],alphabet:3,alreadi:[6,15,19,22],also:[0,11,13,14,17,20,26],altern:[10,20],although:[4,10,17,20],altogeth:12,alwai:[6,11,13,16],amort:[17,20],amount:6,analysi:[10,23],anamorph:14,ani:[8,10,11,14,16,17,20,22,24],annual:14,anonym:[17,20],anoth:[4,13,17,20,26],answer:6,anyth:[2,3,14],aoc20017:5,aoc20173:6,aoc2017:[4,5,6,7,8,9],api:16,app1:3,app2:[3,5,14,18,19],app3:3,app:14,appear:[2,7,10,11,17,20],append:8,appendix:23,appli:[2,3,5,11,17,20],applic:12,approach:[11,18],approxim:23,archiv:0,aren:22,arg:[2,3],argument:[2,3,12,13,14,15,25,26],arithmet:2,ariti:2,around:[11,26],arrai:8,arrang:[8,21],arriv:[12,20,21],articl:[0,10],ask:[6,10,12],aspect:[0,6],assembl:8,assert:[6,9],assign:26,associ:[17,20],assum:[4,5,7,8,15],asterisk:[20,21],attack:14,attempt:[0,1],attribut:3,automat:[10,13],auxiliari:21,avail:[0,7],averag:[14,19],avoid:[17,20],awai:17,awar:2,awkward:[17,20],azur:23,back:[6,8,17,20],backward:[16,17,20,21],bag:14,banana:[13,20],bank:9,barb:13,base:[0,2,3,5,9,13,16,21],basic:[1,2,3,4,6,14,17,20],bear:8,beat:8,becaus:[2,3,4,5,6,8,13,14,17,20,21,22,26],becom:[4,17,18,20,21,26],been:[13,15,16,17,20,22],befor:[5,8,12,13,14,17,20],begin:[6,13,17,20,21],behavior:[16,20,21],behaviour:[0,1],behind:8,being:0,belong:8,below:[2,3,6,11,12,17,20,22],bespok:14,best:0,better:[6,11,12,17,20],between:[0,5,6,11],biannual:14,big:[6,8,20],binari:[0,12,14,20,23],binary_search_tre:[17,20],binarybuiltinwrapp:3,bind:14,bingo:22,bit:[6,11,12,17,20],block:[9,11],bodi:[2,14,17,20],body_text:3,bool:[5,13],borrow:14,both:[2,6,8,11,13,14,18,19,20,26],bottom:12,boundari:6,bracket:[6,14,24],branch:[3,4,5,8,11,12,20],breakpoint:14,bring:[11,14],btree:[17,21],buck:[17,20],bug:[0,14],build:[13,14,20,22,26],built:[13,18],bundl:[2,3],burgeon:14,calcul:6,calculu:10,call:[2,13,14,15,16,17,18,20,25,26],caller:[17,20],came:[8,20],can:[0,2,3,4,5,6,10,11,12,13,14,15,16,18,19,21,22,23,26],candid:5,captur:14,card:14,care:[6,11,26],carefulli:[20,22],carri:[4,6,13,17],cartesian:10,categor:[0,18,23],categori:10,ccc:10,ccon:[17,20],ceil:6,certain:[14,26],certainli:[17,20],chain:3,chang:[2,6,8,16,17,20,22],charact:22,chat:14,chatter:0,cheat:9,check:[5,12,13],checksum:5,child0:20,child:21,childn:20,children:20,choic:[3,13],choos:[16,20],cinf:17,circuit:10,circular:[4,20],cite_not:[17,20],classmethod:3,clear:[3,6,11,14],clear_stuff:17,cleav:[4,5,7,14,18,19],close:[0,1,10],clunki:11,cmp:[3,21,23],cmp_:[3,20],code:[0,1,10,13,20,23],collaps:13,collect:[10,12,14],column:6,combin:[0,3,7,11,12,14,15,18,21,22,23],come:[6,8,14,17],command:[4,14,17,18,20],common:[2,11,13],compar:[3,6,10],comparison:[0,17],compel:10,compil:[2,8,10,13,14,17,19],complet:10,complex:[3,22],compos:13,compound:[17,20],comput:[2,5,6,8,10,11,14,18],con:[3,5,8,9,11,12,13,14,15,17,18,21,22,26],conal:10,concat:[3,4,12,13,14,20,21],concaten:0,concatin:[0,3,26],concis:6,concret:13,concurr:2,cond:[3,17],condit:[8,14],condition:5,confid:6,conflict:[17,20],cons2:20,consecut:[12,23],consid:[8,11,12,13,17,20,21,22],consist:[2,6,14,20,21],constant:[17,20],constitu:13,consum:[5,13],contain:[0,2,3,6,7,12,13,14],context:2,conting:17,continu:[0,5,13,22],control:14,conveni:10,convert:[13,19,20,21,24,26],cook:13,cool:[17,20],copi:[2,3,4,11,13,17,20,21,23],copyright:14,corner:6,correct:6,correctli:20,correspond:10,could:[2,6,8,10,11,13,14,16,17,20,22],count:[3,6,7,12],count_stat:9,counter:11,coupl:21,cours:[6,8,11,13,17,20],cover:6,cpu:6,crack:[17,20],crap:[],crash:[17,20],creat:[0,2,3,4,11,12,13,15,17,20],crude:[17,20,24],current:[2,3,8,13,14,21,22,25],custom:16,cycl:[11,12],cython:14,dai:[13,14],data:[2,3,6],datastructur:[0,2,13,22,23,24,26],datatyp:26,ddididi:22,deal:[0,4,17,20],debugg:13,decid:[17,20],decor:3,decoupl:13,decreas:6,decrement:3,deduc:11,deeper:0,deepli:10,def:[3,6,8,9,13,14,18,19,20,26],defi:3,defin:[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,22,23],definit:[2,3,7,8,11,12,13,14,15,16,17,20,21,23],definitionwrapp:[3,8,13,17,20,21],deleg:14,delet:23,demonstr:[10,13],depend:[3,13,17,20],deposit:[20,21],dequot:[4,13],der:17,deriv:[2,3,4,5,11,14,15,17,23],descend:5,describ:[3,10,13,17,20,21,24],descript:[11,14,20],design:[2,3,5,17,20],desir:[6,14,20,21],destruct:[17,20],detail:[6,14,17,20],detect:[5,12,13,17,20],determin:[5,6],develop:[0,12,14,23],diagram:11,dialect:1,dict:[1,3],dictionari:[0,1,3,14,15,18,20,23],did:6,didn:13,differ:[0,5,7,10,11,13,15,17,18,20,26],differenti:10,dig:[17,22],digit:[4,11],dimension:6,dinfrirst:14,dip:[3,5,6,8,9,11,12,13,14,15,17,18,19,20,21],dipd:[3,8,12,13,14,17,18,20,22],dipdd:[3,17,20],direco:[9,15],direct:14,directli:[6,11,20,21,26],disappear:2,discard:[3,12,13,15,17,20],disciplin:17,discov:5,disenstacken:[14,20],disk:14,displac:2,distanc:6,distribut:9,ditch:[17,20],div:[3,14],dive:[20,21],divid:5,divis:[5,17,20],divisor:5,divmod:[3,5],divmod_:3,doc:[2,3,14],document:[23,24,26],doe:[0,1,5,6,8,10,13,14,23,25],doesn:[4,8,11,13,16,17,20,21,26],dog:20,doing:[6,10,11,13,14,22],domain:[6,10],don:[5,6,8,11,14,17,20],done:[2,11,12,14,16],doodl:6,door:14,dot:25,doubl:[11,14],down:[2,3,6,8,15,22],down_to_zero:14,downward:8,dozen:14,draft:[9,10,16],dream:14,drive:12,driven:[11,15],driver:12,drop:[3,4,17,20],dudipd:14,due:4,dummi:5,dup:[3,4,5,6,8,9,11,12,13,14,15,17,18,20,22,26],dupd:3,dupdip:[3,5,6,11,13,17,18,20],duplic:[3,7,13,17,20],durat:2,dure:[2,13],each:[2,3,4,5,6,8,10,11,13,14,19,20,21,25],easi:[0,6,17,20,21,22],easier:[3,4,17,20],easili:10,edit:23,effect:[2,3,14,22],effici:[6,8,19,22],either:[1,2,3,5,13,17,20],eleg:[8,14,17,18,20],element:[2,3],elliott:10,els:[2,3,4,5,8,9,13],embed:[10,17,20,22],empti:[3,5,14,21,26],encapsul:14,enclos:14,encod:[8,12],encount:8,end:[6,8,11,13,17,21,26],endless:12,enforc:[2,14],engend:14,enlarg:6,enough:[6,13,14,18,25],enstacken:[12,14],ensur:7,enter:14,entir:26,entri:[3,22,25],epsilon:15,equal:[11,21,26],equat:[6,14,15],ergo:[6,13,17,20],err:[17,20],error:[6,14,24],escap:8,essai:0,etc:[3,6,21,22,24],euler:23,eval:0,evalu:[1,2,3,4,13,14,15,17,18,19,20,21],even:8,evenli:5,eventu:[6,18],everi:12,everyth:[3,17,20],evolv:16,exactli:13,exampl:[0,3,4,5,6,7,8,11,12,13,15,20,23,24,26],exce:12,except:[14,17,20,24],execut:[0,1,2,3,5,14,19,21,22,26],exercis:17,exist:[10,17],exit:8,expand:17,expect:[2,3,5,13,20,21,26],experi:[14,21],experiment:6,explan:14,explor:14,express:[0,1,2,3,10,13,17,19,20,22,25,26],expression_to_str:26,extend:6,extra:[4,5,11],extract:[17,23],extrem:14,extrememli:14,facet:0,facil:14,fact:[20,24],factor:[2,11,14,17],fail:[2,3,5,17,20,24],fals:[2,3,5,9,11,13],far:[8,13,15,17,20],fascin:0,fast:6,faster:6,favorit:18,fear:[17,20],feel:6,few:[6,11,14],fewer:[3,14],fib:12,fib_gen:12,figur:[2,3,6,17,20],filter:[17,20],fin:11,find:[2,3,4,5,11,12,20,21,23],finder:15,fine:[0,11,17,20],finish:18,first:[3,4,5,6,8,9,12,13,14,15,17,18,19,20,21,22,23],first_two:17,fit:[11,14,18],five:[11,13,14],fix:[2,3],flag:5,flatten:[14,20,21],flexibl:[20,23],floor:[3,6],floordiv:11,flow:14,follow:[0,2,3,5,8,13,14,15,16,21,22],foo:[14,16,17,20],foo_ii:16,form:[2,3,5,7,10,11,12,21,26],forman:14,format:[23,25],formula:[0,6,11,23],forth:[4,8,14,20],fortun:8,forum:0,forward:[5,8],found:[8,9,14,20],four:[2,3,6,8,11,12,14,17,20],fourteen:11,fourth:[2,3,4,17,20],fractal:14,fraction0:14,fraction:[2,14],framework:14,free:[10,14,17,20],freeli:[2,6],from:[0,1,2,3,4,5,6,7,8,9,11,12,14,15,17,18,19,20,21,22,23,26],front:[2,3],full:[7,11],fun:6,functionwrapp:[3,20],funtion:[17,20],further:[15,23],futur:18,garbag:14,gari:[17,20],gcd:14,gen:9,gener:[2,3,6,8,10,23,26],genrec:[3,5,8,13,14,17,20,21],geometr:11,geometri:20,get:[2,5,6,10,11,12,13,14,23],get_valu:8,getitem:3,getrecursionlimit:26,getsourc:14,ghc:10,give:[6,10,11,13,15,17,21,26],given:[2,3,4,5,6,8,9,11,12,15,17,22,23],glue:14,goal:8,going:[5,6,8,17,20,21,22],good:[8,11,17,20],grab:3,grammar:24,grand:14,graph:6,great:[0,4,6,14,23],greater:[6,26],grid:6,group:[0,6],gsra:15,guard:[5,6,17],had:[11,22],haiku:14,half:[11,22],half_of_s:4,halfwai:4,hand:[14,18,19,20,23],handi:15,handl:[17,26],happen:[6,14,20],hard:22,hardli:13,hardwar:10,has:[0,2,5,6,8,12,13,14,15,16,17,20,22,26],haskel:10,have:[2,3,4,5,6,8,9,11,12,13,14,15,16,20,22,23,26],head:[5,13,26],help:[7,13,14,17,20],help_:3,helper:[3,5],herd:14,here:[6,11,12,13,17,18,20,21,22],heterogen:20,heurist:[4,8],hide:[17,20],higher:[14,17,20],highest:[5,20],highli:[14,20],hindsight:5,histori:25,hmm:[17,20],hog:20,hoist:3,hold:11,hood:[8,17],hope:[0,11,14,23],host:23,how:[0,6,7,8,10,13,17,20,22],html:[2,3,12,18,23],http:[17,20],huet:22,huge:17,hugh:[15,20,21],human:14,hypothet:2,id_:3,idea:[10,11,14,20],ident:[3,13],identifi:6,if_not_empti:17,ift:[3,4,5,8,13,17,20,21],ignor:[3,17,20],illustr:13,imagin:22,imit:21,immedi:[8,13],immut:[14,17,20],imper:13,implement:[0,1,2,3,6,9,10,13,14,16,17,18,20],impli:5,implicit:14,includ:[7,10,17,21],inclus:11,incom:26,incompat:16,incr_at:8,incr_step_count:8,incr_valu:8,increas:[6,8,11],increment:[3,10,11,16],index:[0,6,9,14,26],index_of:9,indexerror:26,indic:[20,21],infil:20,infinit:6,inform:3,infra:[3,12,13,14,17,18,19,21],infrastructur:3,init:8,init_print:6,initi:[2,3,5,6,7,8,14,15,17,20],inlin:[17,20],inner:5,input:[1,4,5,6,7,13,15],inscrib:3,inspect:14,instal:0,instanti:[10,25],instead:[6,11,12,13,17,20,22,26],instruct:8,integ:[2,3,4,5,6,7,8,12,13,14,21],integr:3,intend:[0,14],interact:[14,23],interest:[0,6,11,12,17,20],interlock:6,interlud:23,intermedi:13,intern:[0,25,26],interpret:[0,10,13,16,24,25],interrupt:14,interv:[10,11],introduc:16,introduct:0,invari:3,invers:3,investig:18,ipf:14,ipynb:12,isn:[13,17,22],item:[2,3,4,5,9,13,14,17,20,21,26],iter:[1,3,6,13,14,21,23,26],iter_stack:[9,19,26],its:[0,2,3,5,6,10,11,13,14,17,20,21,26],itself:[0,2,8,14,17,20],j05cmp:[2,3],jenni:20,job:[8,23],john:[15,20,21],joi:[2,4,5,7,8,9,10,15,16,17,18,19,20],joypi:[8,9,13,14,20,22],jump:8,jupyt:23,just:[0,2,3,4,5,6,8,12,13,14,16,17,21,22],keep:[17,22],kei:[21,23],kevin:0,key_n:[17,20],keyerror:[17,20],kind:[2,6,8,10,13,14,17,20,21],kleen:[20,21],know:[6,11,13,17,20],known:10,l_kei:17,l_left:17,l_right:17,l_valu:17,labda:[],lambda:[10,13],lambdifi:6,languag:[10,14,16,17,18,20],larg:6,larger:[6,26],largest:[3,5,8],last:[4,8,11,13,17],lastli:[12,13],later:[8,14,21],law:2,lazi:15,lazili:15,lcm:11,lead:[8,14],leaf:[17,20],lean:14,learn:[0,9],least:[2,6,8,11,13,26],least_fract:14,leav:[5,6,8,11,12,20],left:[6,12,13,14,21,22,25,26],leftov:13,legendari:8,legibl:8,len:9,length:[3,11,26],lens:13,less:[11,12,13,14,26],lesser:6,let:[4,5,6,8,12,13,15,17,18,20,21,22],level:[10,17,20],librari:[0,6,8,9,15,18,19,20],lieu:20,like:[2,3,5,6,9,11,13,14,15,18,21,23,24],line:[3,5,8,13,14,17,20,25],linear:26,link:0,linux:0,list:[0,3,4,5,7,8,9,11,14,15,17,21,22,25],list_to_stack:[8,9,26],liter:[1,17,20,21,22,24],littl:[6,8,17,20,23],live:23,lkei:[20,21],load:[11,14],locat:[2,6],locu:25,log_2:[17,20],logic:[0,11],longer:[17,20],look:[6,12,14,15,17,20],lookup:[14,20],loop:[0,1,3,11],lot:[14,17,18,20,22],love:11,low:10,lower:[11,20],lowest:[5,17,20],machin:[0,20],machineri:[17,20],macro:14,made:[0,5,14,20,22],mai:[2,8,13,20],mail:0,main:[0,3,4,14,22],mainloop:16,maintain:22,major:16,make:[2,3,4,10,11,13,14,17,19,21,22],make_distributor:9,make_gener:15,manfr:[0,2,3,10],manhattan:6,mani:[0,6,7,8,12,13,14],manipul:6,manual:[6,13],map:[1,3,11,13,14,16,18,20,21],map_:3,mark:[6,8],marker:14,mask:[11,12],match:[0,1,4],materi:0,math:[0,6,8,14,17,20],mathemat:[6,14],matter:[4,11,13,15,17,20,21],max:[5,6,9],max_:3,maximum:[3,20],maxmin:5,mayb:[13,17,20],maze:8,mean:[5,10,11,13,14,15,17,20,21,26],meant:[13,14,17,18,20,21],meantim:8,mem:8,member:[2,3,6],memori:6,mental:14,mention:2,mercuri:0,merg:20,meta:[14,17,20],methink:20,method:[0,3,6,14,23,25],mfloor:6,midpoint:11,might:[4,10,12,13,17,20],mike:17,million:12,min:5,min_:3,mind:8,minimum:3,minor:17,minu:[3,18],mirror:0,miscellan:0,mistak:9,mix:14,mnemon:4,mod:3,model:[10,14],modern:0,modif:12,modifi:[8,14,17,22],modul:[0,1,3,14,24],modulu:14,monkei:6,month:14,more:[0,3,7,8,10,11,12,13,14,15,18,19,20,21,24,26],most:20,mostli:0,move:[4,6,8,17],movement:2,mrank_of:6,much:[6,8,11,13,17,20],muck:[17,20],mul:[14,18,22,25],multi:3,multipl:[13,23],must:[2,3,5,6,7,11,13,16,21],mutabl:8,n_rang:12,nail:8,name:[1,3,4,14,16,17,22,23,24,26],natur:[11,12,17,20],navig:22,neat:17,need:[2,3,4,5,6,8,9,11,12,13,15,16,17,20],neg:[3,8,18],nest:[14,17,20,22],network:14,never:16,new_kei:17,new_valu:17,newton:[0,23],next:[4,5,6,8,11,13,20,21],nice:[0,4,6,13,26],niether:2,node:[21,23],node_kei:[17,20],node_valu:[17,20],non:[5,20,21],none:[1,3],nope:21,normal:[7,13],notat:[14,17,20],note:[2,6,11,15,17,20,26],notebook:[11,14,22,23],notebook_preambl:[2,4,5,6,7,8,9,11,12,13,15,17,18,19,20,21,22],noth:[2,17,20],notic:11,now:[4,5,6,11,12,13,14,19,21,23],nth:[3,26],nullari:[5,8,9,14,17,20],number:[1,2,3,5,11,12,26],object:24,observ:11,obviou:12,obvious:[5,7,8],occur:[17,20],odd:[11,12],off:[2,3,6,11,12,22],offset:8,offset_of:6,old:[2,19],old_k:17,old_kei:17,old_valu:17,omit:13,onc:[3,7,16,17,18,20],one:[2,3,4,5,6,7,8,11,12,13,17,18,20,21,25,26],ones:12,onli:[2,3,4,5,6,8,11,13,17,20,22,26],onto:[1,2,3,14,26],open:[7,14],oper:[3,5,13,14,17,20,26],oppos:4,optim:17,option:[1,14,17,20,26],order:[0,2,3,4,5,13,14,23,26],org:[0,17,20],origin:[0,1,2,3,4,17,20,22],other:[0,2,3,5,6,10,13,14,17,20,21,26],otherwis:[3,5,11,12,17,20,21],our:[4,5,6,11,12,13,14,15,21],ourselv:13,out:[2,3,6,10,11,12,13,14,17,20,22],outcom:[20,21],output:[6,13,15],outsid:[8,10],outward:6,over:[3,4,6,10,11,12,14,15,17,18,20,21,23],overhead:6,overkil:13,overshadow:6,own:[6,17,20],pack:[20,26],packag:[0,14],page:[0,17,18,20,26],pair:[2,3,4,5,11,12,17],pair_up:4,palidrom:11,palindrom:11,pam:[14,18],paper:[6,10,13,14,20,22],parallel:2,paramet:[1,2,3,8,13,24,25,26],parameter:23,paranthes:20,parenthes:[8,17,20,26],pariti:12,pars:[0,3,14,20],parse_definit:3,parseerror:24,parser:0,part:[2,3,5,8,13,15,18,20,21],partial:[6,13],particular:22,particularli:8,pass:[0,17,20,25],passphras:7,path:6,pattern:[6,11,20,21],payoff:13,pe1:[11,12],pe2:12,pearl:22,pend:[3,13,14,22,25],peopl:23,per:[6,14,21],perform:8,perhap:12,period:14,permit:[8,26],persist:[17,20],phase:2,pick:[11,12,26],pickl:14,pictur:[17,20],piec:13,pip:0,pita:9,place:[3,6,8,11,13,14],plai:0,plain:8,plane:6,plu:[3,6,18],plug:[12,13,20,21],point:[6,10,13,14,17,20],pointless:2,pop:[3,4,5,8,9,11,12,13,14,17,18,19,20,21,26],popd:[3,8,14,15,17,19],popdd:[3,5,12,18],popop:[3,4,5,8,9,11,12,13,14,15,17,20,21],port:6,posit:[3,8,11,13,14],possibilit:[17,20],possibl:[5,17,20,21,23],post:[14,20],potenti:3,power:14,pragmat:11,pre:[8,13,20],preambl:15,precis:[0,1],pred:3,predic:[2,5,12,13],prefer:13,prefix:[13,25],prep:[5,20],prepar:[8,13],preprocessor:13,present:20,preserv:[10,21],pretti:[6,17,18,20,21,25,26],pretty_print:0,prevent:13,previou:[6,8,14],prime:[5,15],primit:[2,3,8,18],primrec:[3,5,8,9,12,13,14,15],print:[0,1,2,3,6,13,25,26],probabl:[4,12,14,17,20],problem:[6,14,23],proc_curr:[17,20],proc_left:[17,20],proc_right:[17,20],proce:[4,11],process:[8,13,14,21,25],processor:20,produc:[4,11,13,17,20,21],product:14,program:[0,2,3,4,5,6,8,12,14,15,17,22],project:23,prompt:14,proper:[2,3],properli:8,properti:0,provid:[0,3,10,14],prune:20,pun:[0,14],pure:[0,20],puriti:14,purpos:14,push:[2,3,13,14,22,26],pushback:[14,20,26],put:[1,2,12,14,23,26],puzzl:[4,5,6,7],pypi:0,pyramid:6,python:[0,2,3,6,8,13,17,18,20,22,23,24,26],quadrat:[0,6,23],queri:[17,20,21],query_kei:21,queu:13,quit:[0,1,6,21],quot:[0,3,12,13,14,15,17,18,20,21,22,25],quotat:[2,3],quotient:3,r_kei:17,r_left:17,r_right:17,r_valu:17,rais:[17,20,24,26],random:8,rang:[6,13,14],range_sum:13,range_to_zero:14,rank_and_offset:6,rank_of:6,raphson:15,rather:[11,13,14,20,21],ratio:14,reach:[8,11,12,13],read:[0,1,11,12,17,20,22],readabl:19,reader:17,real:[17,20],realiz:[4,8,10,17,20],realli:6,rearrang:[2,13,17],reason:[6,11,14],rebuild:[21,22],rec1:[2,3],rec2:[2,3],recogn:24,record:[14,25],recur:13,recurs:[2,3,5,8,9,12,14,15,23,26],recus:14,recusr:20,redefin:23,redistribut:[3,14],reduc:2,redund:26,reexamin:20,refactor:[13,14,16],refer:[0,2],regist:2,regular:24,reimplement:23,rel:[8,18],releas:16,relev:6,remain:[2,3,14,16],remaind:[3,15],remind:13,remov:[3,6,17,20,26],renam:20,render:[20,23],repeat:[4,6,11],repeatedli:11,repl:[0,1],replac:[0,2,3,12,13,20,21,22,23,26],repositori:0,repres:[2,14,17,20,24,25],represent:26,reprod:12,request:6,requir:[6,26],resembl:14,respect:11,rest:[3,5,9,11,12,14,17,20,22,23,26],rest_two:17,restor:2,result:[1,2,3,5,11,12,13,17,18,20,21,22],resum:14,retir:2,retri:14,reus:[17,20],revers:[3,4,5,11,12,13,22,26],rewrit:[3,8,14],rewritten:14,richard:20,rid:[17,20],right:[6,12,13,14,21,25,26],rightest:17,rightmost:11,rkei:[20,21],role:20,roll:[3,5,7,8,13,15,17,18,20,21],rolldown:3,rollup:3,root:[3,6,18,23],rotate_seq:4,round:4,row:[5,6],row_valu:6,run:[0,1,3,6,11,13,14,15,17,20,21,22],runtim:6,runtimeerror:26,sai:[17,20,21],same:[2,10,11,13,17,20,26],sandwich:[2,3],save:[2,11,14],scan:3,scanner:[14,24],scenario:22,scheme:[18,20],scope:[4,17,20],search:[0,6,17,20],second:[3,4,5,13,14,17,20,21,26],secur:7,see:[0,6,12,13,14,16,19,20,22,25],seem:[0,9,11,14,20,21],seen:22,select:[3,6],semant:[2,3,14,16,17,20],semi:14,send:14,sens:[0,2,11,22],separ:14,sequenc:[0,1,2,3,4,5,7,8,9,11,14,17,19,20,22,24],seri:[6,11,12,13,17,20,22],serv:13,set:[2,3,13,23],seven:[11,12],sever:[0,10,14],share:[3,6,14],shelf:2,shift:[11,12],shine:8,shorter:23,shortest:6,shorthand:17,should:[2,5,11,13,17,20],shouldn:14,show:[6,10,20,22],shunt:[3,22],side:[17,20],sign:6,signal:5,signifi:[14,17,20],silli:20,similar:[17,20,21],simon:14,simpl:[6,13,14,26],simplefunctionwrapp:[3,8,9,18,19],simpler:21,simplest:23,simpli:10,simplifi:[6,11,17,20,22],sinc:[2,6,11,17,18,20],singl:[3,12,14,19,24],situ:[17,20],situat:[17,20],six:[11,12,14],sixti:[11,12],size:[4,7,8,9,14,23],skeptic:14,skip:[6,8],slight:15,slightli:[13,17,20],small:[4,20],smallest:[3,5],smart:[8,13,17],sneaki:6,softwar:14,solei:2,solut:[6,11],solv:6,solvabl:14,some:[2,3,5,6,8,12,13,14,17,20,21,23,26],somehow:[17,20],someth:[2,4,8,16,17],sometim:[17,20],somewher:[13,17,20,23],sophist:6,sort:[3,5,13,17,18,20],sort_:3,sourc:[0,1,3,23,24,25,26],space:[6,11,25],span:11,special:[12,13,17,20],specif:[0,10],specifi:17,speed:[6,8,19],spell:21,sphinx:[23,26],spiral:6,spirit:[0,1,20,21],split_at:4,spreadsheet:5,sqr:[14,18,22],sqrt:[3,6,15,18],squar:[3,6,23,24],stack:[0,1,3,5,8,9,11,12,13,15,17,18,19,20,21,22,24,25],stack_:3,stack_to_str:26,stage:[20,21],stai:[0,1],stand:10,standard:[14,17],star:[20,21],stare:[17,20],start:[5,6,8,9,11,12,13,14,15,17,18,20,21],state:[5,8,14],statement:3,step:[3,4,5,6,7,11,14,17,18,19,20,22,23],step_zero:[4,5,7],still:[6,8,13,17],stop:[17,20],storag:[11,13,17,20],store:[6,11,13],stori:13,str:[1,24,25,26],straightforward:[1,4,6,12],strang:8,stream:[11,15],stretch:17,string:[1,2,3,4,14,22,24,25,26],strip:6,structur:[13,14,20,21,22,23,26],stuff:[17,20],style:[0,10],sub:[16,20],subclass:14,subject:22,subract:6,substitut:[6,13,17],subtract:[5,6,11],succ:3,success:15,suffici:[8,13,17],suggest:[5,10,17,20],suitabl:[3,10,11],sum:[3,4,5,12,13,14,18,19,20,21],sum_:3,summand:11,sumtre:21,suppli:[13,17,20,24],support:[6,14,25,26],sure:[6,13],suspect:2,swaack:[3,13,18,19,20,22],swap:[3,4,5,6,7,9,11,12,13,14,15,17,19,20,21,22],swon:[3,9,12,13,14,20,21,22],swoncat:[8,9,12,13,14,15,20,21],symbol:[2,3,6,18,22,24],symmetr:[11,17,20],sympi:18,syntact:14,syntax:[14,26],sys:[6,26],system:[6,7,14,17,20],tail:[5,17,20,26],take:[3,4,6,8,11,12,14,15,17,18,20,26],taken:8,talk:[14,17,20,26],target:[6,22],task:6,tast:10,tbd:14,technic:2,techniqu:[10,22],technolog:2,teh:20,temporari:22,ten:11,term:[1,2,5,8,9,13,14,15,23,24,26],termin:[2,3,5],ternari:14,test:[2,3],text:[0,1,3],text_to_express:[14,24],textual:14,than:[0,3,6,7,11,12,14,15,18,21,26],thei:[2,5,6,11,12,13,14,17,20,22,24,26],them:[2,3,5,6,11,12,13,17,20,22,23],theori:[2,3],therefor:[12,20],thi:[0,1,2,3,4,5,6,8,9,10,11,12,13,14,18,21,22,23,24,25,26],thing:[2,5,6,8,12,13,17,18,20,22,24,26],think:[2,8,11,13,14,17,20,21],third:[3,4,5,12,14,17,20],thirti:11,those:[2,3,5,6,8,13,17,20,23],though:[11,12,20],thought:14,thousand:11,thread:2,three:[2,3,8,11,14,17,20,21],through:[1,11,14,21,22,26],thu:4,thun:[2,3,10,16],thunder:14,tied:20,tile:6,time:[3,6,8,9,11,13,14,17,20,22],tini:20,to_set:[17,20],todai:14,todo:[14,24],togeth:[12,14,23],token:24,toler:23,tommi:20,too:[13,20],took:6,tool:14,top:[2,3,14,25,26],total:[4,6,11],total_match:4,trace:[0,14,18,22,23,26],traceprint:25,track:22,tracker:0,trade:6,transform:[10,13],translat:[6,10,13],travers:[22,23],treasur:0,treat:[0,2,3,23],treatment:12,tree:[0,14,23],treegrind:23,treemap:13,treestep:[0,23],tri:11,trick:[11,20],tricki:[6,8],trivial:[5,8,20],trobe:0,trove:0,truediv:18,truthi:[3,14],ts0:[13,20],ts1:[13,20],tuck:[3,5,14,20],tupl:[3,14,26],turn:[2,3,6],twice:[6,13,17,20],two:[2,3,5,6,11,13,14,15,17,20,21,22,26],type:[1,10,13,14,17,24,25,26],typic:[2,3],unari:[8,13,14],unarybuiltinwrapp:3,unbalanc:[17,20,24],unchang:17,uncon:[3,4,5,12,13,14,17,20,21,22],under:[2,3,8,14,17],understand:[0,6,17,20],undistinguish:17,undocu:14,unfortun:26,uniqu:[3,7,17,20],unit:[4,13,14,20],univers:[0,14],unless:[6,13],unlik:13,unnecessari:23,unpack:[2,3,17,26],unpair:11,unquot:[13,14,20,21],unstack:3,untangl:[12,13],until:[5,6,8,12],unus:11,unusu:[17,20],updat:[0,23],upward:8,usag:14,use:[0,2,3,6,8,10,11,12,14,15,16,17,18,19,20,21,22,26],used:[3,10,13,14,17,20,22,24,26],useful:0,user:[6,21],uses:[2,5,11,13],using:[3,5,6,12,13,17,18,20,21,22],usual:[0,2],util:[0,8,9,19,20],valid:7,valu:[2,3,5,6,11,13,14,15,19,21,23,26],value_n:[17,20],valueerror:26,vanilla:8,variabl:[13,23],variant:17,variat:13,varient:20,varieti:[10,14],variou:0,vener:26,verbos:10,veri:[0,1,6,10,14,17,20,26],versa:2,version:[0,1,2,12,16,18,21,22,23],via:14,vice:2,view:[17,23],viewer:[1,14,16,25],von:[0,2,3,10],wai:[0,2,3,4,6,8,10,11,13,14,20],walk:20,wall:6,want:[2,6,8,11,12,15,17,20],warranti:[3,14],wash:14,wast:14,web:26,websit:[0,11],welcom:14,well:[0,4,5,6,10,14,17,20,24],were:[6,8,13,14,22],what:[2,3,5,8,9,10,13,14,17,18,20,21,25],whatev:[2,3,12,20,21,26],when:[11,12,13,14,15,17,20,22,24,26],where:[2,3,4,5,8,13,14,17,20,23,26],whether:13,which:[0,1,3,5,6,8,11,13,14,15,17,18,20,21,22,26],whole:[2,3,5,11,20,21],whose:12,why:[6,15,20,21],wiki:[17,20],wikipedia:[0,17,20,22],wildli:14,wind:14,winner:6,wire:13,wit:8,within:[14,17,20,23],without:[2,14,17,20],won:[17,20,26],word:[0,3,4,5,7,11,12,14,20,22],work:[0,3,4,5,6,8,11,12,13,14,17,20,21,22,26],worth:[6,11],would:[2,5,6,7,8,9,11,12,13,14,15,17,20,22,26],wouldn:8,wrap:[3,6,14],write:[4,6,8,10,12,13,15,17,20,21,22,23,26],written:[0,1,8,15,17,18,19,26],wrong:2,wtf:13,wtfmorphism:13,year:14,yet:[8,13,17,20,22],yield:[2,3,26],you:[0,2,3,5,6,8,11,12,13,14,16,17,19,20,21,22,25,26],your:[2,3,4,5,6,7,14],yourself:[14,17,20],zero:[3,5,6,8,13,17,20,21,24,26],zip:[4,11],zip_:3,zstr:22},titles:["Thun 0.2.0 Documentation","Joy Interpreter","Functions Grouped by, er, Function with Examples","Function Reference","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Advent of Code 2017","Categorical Programming","Developing a Program in Joy","Using <code class=\"docutils literal notranslate\"><span class=\"pre\">x</span></code> to Generate Values","Hylomorphism","Thun: Joy in Python","Newton\u2019s method","No Updates","Treating Trees I: Ordered Binary Trees","Quadratic formula","Replacing Functions in the Dictionary","Treating Trees","Treating Trees II: <code class=\"docutils literal notranslate\"><span class=\"pre\">treestep</span></code>","Preamble","Essays about Programming in Joy","Parsing Text into Joy Expressions","Tracing Joy Execution","Stack or Quote or Sequence or List\u2026"],titleterms:{"1st":4,"2nd":5,"3rd":6,"4th":7,"5th":8,"6th":9,"case":[15,17,20],"final":5,"function":[2,3,9,13,14,15,17,18,19,20,21],"long":19,"new":17,"void":2,"while":2,Adding:[17,20],One:[12,17],The:[11,13,14,17,20,21],There:14,Use:20,Using:12,With:21,about:23,abov:13,add:[2,8,17,20],adding:[17,20],address:22,advent:[4,5,6,7,8,9],all:[6,8],altern:21,ana:13,analysi:[6,11],anamorph:[2,13],app1:2,app2:2,app3:2,appendix:[13,17],approxim:15,automat:20,averag:2,base:[15,17,20],befor:9,better:13,binari:[2,17,21],block:5,both:17,branch:[2,17],breakdown:8,btree:20,can:[17,20],cata:13,catamorph:13,categor:10,chatter:2,check:18,child:[17,20],choic:2,cleanup:18,clear:2,cleav:2,cmp:[17,20],code:[4,5,6,7,8,9,14,17],combin:[2,13,17,20],compar:[17,20],comparison:2,compil:12,comput:15,con:[2,20],concat:2,consecut:15,continu:14,count:[8,9],crap:20,current:[17,20],data:20,datastructur:[14,17,20],decemb:[4,5,6,7,8,9],defin:[17,18,20,21],definit:18,delet:[17,20],deriv:[13,18,20,21],determin:22,develop:11,dialect:0,dictionari:19,dip:[2,22],dipd:2,dipdd:2,direco:12,disenstacken:2,div:2,document:0,doe:[17,20],down:5,down_to_zero:2,drive:9,drop:2,dup:2,dupd:2,dupdip:2,els:[17,20],empti:[17,20],enstacken:2,equal:[17,20],essai:23,euler:[11,12],eval:14,even:12,exampl:[2,14,17,21],execut:25,express:[14,24],extract:[13,20,21],factor:[13,20],factori:13,fibonacci:12,filter:11,find:[6,13,15,17],first:[2,11],five:12,flatten:2,flexibl:21,floordiv:2,form:[13,20],formula:18,found:17,four:13,from:13,ftw:4,fun:13,further:11,fusion:13,gcd:2,gener:[9,11,12,13,15,20],genrec:2,get:[8,17,20,21],getitem:2,given:[13,20,21],gotten:8,greater:[17,20],group:2,have:[17,21],help:2,highest:17,host:0,how:[9,11,12],hylo:13,hylomorph:13,ift:2,increment:8,index:8,indic:0,inform:0,infra:[2,20,22],integ:11,interlud:[17,20],intern:24,interpret:[1,14],isn:20,item:22,iter:[11,17,20],joi:[0,1,3,6,11,13,14,22,23,24,25,26],just:[11,20],kei:[17,20],languag:0,law:13,least_fract:2,left:[17,20],less:[17,20],let:11,librari:[3,14],like:[17,20],list:[2,13,20,26],literari:14,littl:11,logic:2,loop:[2,5,14],lower:17,lshift:2,make:[15,20],mani:[9,11],map:2,math:2,method:15,min:2,miscellan:[2,20],mod:2,modif:20,modulu:2,more:17,most:17,mul:2,multipl:[11,12],must:[17,20],name:[18,20],nativ:18,neg:2,newton:15,next:15,node:[13,17,20],non:17,now:[8,17,20],nullari:2,number:[6,13],offset:6,one:14,onli:14,order:[17,20,21],osdn:0,our:[17,20],out:5,over:2,pack:11,pam:2,paper:5,para:13,paramet:20,parameter:[13,17,20,21],paramorph:13,pars:[2,24],parser:[14,24],pass:14,path:22,pattern:13,per:[17,20],piec:5,pop:2,popd:2,popop:2,pow:2,power:12,preambl:[8,13,22],pred:2,predic:[8,11,15,17,20,21],pretty_print:25,primrec:2,print:14,problem:[11,12],process:[17,20],product:2,program:[9,10,11,13,18,20,21,23],project:[0,11,12],pure:14,put:[6,17,20,21],python:[14,19],quadrat:18,quick:0,quot:[2,26],rang:[2,11],range_to_zero:2,rank:6,read:14,recal:9,recur:[15,17,20],recurs:[13,17,20,21],redefin:[17,20,21],refactor:[4,11,17,20],refer:3,regular:14,reimplement:21,rem:2,remaind:2,remov:2,render:11,repeat:9,repl:14,replac:[17,19],rescu:6,reset:12,rest:[2,13],revers:2,right:[17,20,22],rightmost:17,roll:2,rolldown:2,rollup:2,root:15,rshift:2,run:[2,12],sat:5,second:2,select:2,sequenc:[12,26],set:[8,15,17,20],shorter:19,should:14,shunt:2,simplest:11,simplifi:18,size:[2,19],slight:20,sourc:17,sqr:2,sqrt:2,squar:15,stack:[2,14,26],start:0,state:9,step:[2,8,13,21],structur:17,style:14,sub:[2,17],succ:2,sum:[2,11],swaack:2,swap:2,swon:2,swoncat:2,symbol:[13,14],sympi:6,tabl:0,tail:13,take:2,term:[11,12,20,21],ternari:2,text:24,than:[13,17,20],thi:[17,20],think:5,third:2,three:12,thun:[0,14],time:[2,12],todo:20,togeth:[6,8,17,20,21],toi:20,token:14,toler:15,trace:[19,25],traceprint:14,travers:[17,20,21],treat:[17,20,21],tree:[13,17,20,21,22],treegrind:21,treestep:[13,20,21],triangular:13,tricki:5,truediv:2,truthi:2,tuck:2,two:12,type:20,unari:2,uncon:2,unfinish:13,unit:2,unnecessari:11,unquot:2,unstack:2,updat:16,use:13,usual:13,util:[25,26],valu:[8,12,17,20],variabl:18,version:[6,11,17,19,20],view:14,want:5,within:15,word:2,write:18,xor:2,zero:12,zip:2,zipper:22}})
\ No newline at end of file
diff --git a/docs/sphinx_docs/_build/html/stack.html b/docs/sphinx_docs/_build/html/stack.html
index 5e777ef..ce88245 100644
--- a/docs/sphinx_docs/_build/html/stack.html
+++ b/docs/sphinx_docs/_build/html/stack.html
@@ -6,7 +6,7 @@
   <head>
     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Stack or Quote or Sequence or List… &#8212; Thun 0.1.1 documentation</title>
+    <title>Stack or Quote or Sequence or List… &#8212; Thun 0.2.0 documentation</title>
     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     <script type="text/javascript" src="_static/documentation_options.js"></script>
diff --git a/docs/sphinx_docs/conf.py b/docs/sphinx_docs/conf.py
index a1f62cb..12792b6 100644
--- a/docs/sphinx_docs/conf.py
+++ b/docs/sphinx_docs/conf.py
@@ -24,9 +24,9 @@ copyright = u'2018, Simon Forman'
 author = u'Simon Forman'
 
 # The short X.Y version
-version = u'0.1'
+version = u'0.2'
 # The full version, including alpha/beta/rc tags
-release = u'0.1.1'
+release = u'0.2.0'
 
 
 # -- General configuration ---------------------------------------------------
diff --git a/docs/sphinx_docs/notebooks/Categorical.rst b/docs/sphinx_docs/notebooks/Categorical.rst
index b698e53..979ec20 100644
--- a/docs/sphinx_docs/notebooks/Categorical.rst
+++ b/docs/sphinx_docs/notebooks/Categorical.rst
@@ -13,5 +13,5 @@ In `Compiling to categories <http://conal.net/papers/compiling-to-categories/>`_
 
     It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.
 
-What he's doing is translating labda forms into a kind of "point-free" style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.
+What he's doing is translating lambda forms into a kind of "point-free" style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.
 
diff --git a/docs/sphinx_docs/notebooks/Ordered_Binary_Trees.rst b/docs/sphinx_docs/notebooks/Ordered_Binary_Trees.rst
new file mode 100644
index 0000000..77e3bbc
--- /dev/null
+++ b/docs/sphinx_docs/notebooks/Ordered_Binary_Trees.rst
@@ -0,0 +1,1640 @@
+
+Treating Trees I: Ordered Binary Trees
+======================================
+
+Although any expression in Joy can be considered to describe a
+`tree <https://en.wikipedia.org/wiki/Tree_structure>`__ with the quotes
+as compound nodes and the non-quote values as leaf nodes, in this page I
+want to talk about `ordered binary
+trees <https://en.wikipedia.org/wiki/Binary_search_tree>`__ and how to
+make and use them.
+
+The basic structure, in a `crude type
+notation <https://en.wikipedia.org/wiki/Algebraic_data_type>`__, is:
+
+::
+
+    Tree :: [] | [key value Tree Tree]
+
+That says that a Tree is either the empty quote ``[]`` or a quote with
+four items: a key, a value, and two Trees representing the left and
+right branches of the tree.
+
+We're going to derive some recursive functions to work with such
+datastructures:
+
+::
+
+    Tree-add
+    Tree-delete
+    Tree-get
+    Tree-iter
+    Tree-iter-order
+
+Once these functions are defined we have a new "type" to work with, and
+the Sufficiently Smart Compiler can be modified to use an optimized
+implementation under the hood. (Where does the "type" come from? It has
+a contingent existence predicated on the disciplined use of these
+functions on otherwise undistinguished Joy datastructures.)
+
+.. code:: ipython2
+
+    from notebook_preamble import D, J, V, define, DefinitionWrapper
+
+Adding Nodes to the Tree
+------------------------
+
+Let's consider adding nodes to a Tree structure.
+
+::
+
+       Tree value key Tree-add
+    -----------------------------
+                Tree′
+
+Adding to an empty node.
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+If the current node is ``[]`` then you just return
+``[key value [] []]``:
+
+::
+
+    Tree-add == [popop not] [[pop] dipd Tree-new] [R0] [R1] genrec
+
+``Tree-new``
+^^^^^^^^^^^^
+
+Where ``Tree-new`` is defined as:
+
+::
+
+       value key Tree-new
+    ------------------------
+       [key value [] []]
+
+Example:
+
+::
+
+    value key swap [[] []] cons cons
+    key value      [[] []] cons cons
+    key      [value [] []]      cons
+         [key value [] []]
+
+Definition:
+
+::
+
+    Tree-new == swap [[] []] cons cons
+
+.. code:: ipython2
+
+    define('Tree-new == swap [[] []] cons cons')
+
+.. code:: ipython2
+
+    J('"v" "k" Tree-new')
+
+
+.. parsed-literal::
+
+    ['k' 'v' [] []]
+
+
+(As an implementation detail, the ``[[] []]`` literal used in the
+definition of ``Tree-new`` will be reused to supply the *constant* tail
+for *all* new nodes produced by it. This is one of those cases where you
+get amortized storage "for free" by using `persistent
+datastructures <https://en.wikipedia.org/wiki/Persistent_data_structure>`__.
+Because the tail, which is ``((), ((), ()))`` in Python, is immutable
+and embedded in the definition body for ``Tree-new``, all new nodes can
+reuse it as their own tail without fear that some other code somewhere
+will change it.)
+
+Adding to a non-empty node.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We now have to derive ``R0`` and ``R1``, consider:
+
+::
+
+    [key_n value_n left right] value key R0 [Tree-add] R1
+
+In this case, there are three possibilites: the key can be greater or
+less than or equal to the node's key. In two of those cases we will need
+to apply a copy of ``Tree-add``, so ``R0`` is pretty much out of the
+picture.
+
+::
+
+    [R0] == []
+
+A predicate to compare keys.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+::
+
+    [key_n value_n left right] value key [BTree-add] R1
+
+The first thing we need to do is compare the the key we're adding to the
+node key and ``branch`` accordingly:
+
+::
+
+    [key_n value_n left right] value key [BTree-add] [P] [T] [E] ifte
+
+That would suggest something like:
+
+::
+
+    [key_n value_n left right] value key [BTree-add] P
+    [key_n value_n left right] value key [BTree-add] pop roll> pop first >
+    [key_n value_n left right] value key                 roll> pop first >
+    key [key_n value_n left right] value                 roll> pop first >
+    key key_n                                                            >
+    Boolean
+
+Let's abstract the predicate just a little to let us specify the
+comparison operator:
+
+::
+
+    P > == pop roll> pop first >
+    P < == pop roll> pop first <
+    P   == pop roll> pop first
+
+.. code:: ipython2
+
+    define('P == pop roll> pop first')
+
+.. code:: ipython2
+
+    J('["old_key" 23 [] []] 17 "new_key" ["..."] P')
+
+
+.. parsed-literal::
+
+    'new_key' 'old_key'
+
+
+If the key we're adding is greater than the node's key.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Here the parentheses are meant to signify that the expression is not
+literal, the code in the parentheses is meant to have been evaluated:
+
+::
+
+       [key_n value_n left right] value key [Tree-add] T
+    -------------------------------------------------------
+       [key_n value_n left (Tree-add key value right)]
+
+So how do we do this? We're going to want to use ``infra`` on some
+function ``K`` that has the key and value to work with, as well as the
+quoted copy of ``Tree-add`` to apply somehow. Considering the node as a
+stack:
+
+::
+
+       right left value_n key_n value key [Tree-add] K
+    -----------------------------------------------------
+       right value key Tree-add left value_n key_n
+
+Pretty easy:
+
+::
+
+    right left value_n key_n value key [Tree-add] cons cons dipdd
+    right left value_n key_n [value key Tree-add]           dipdd
+    right value key Tree-add left value_n key_n
+
+So:
+
+::
+
+    K == cons cons dipdd
+
+Looking at it from the point-of-view of the node as node again:
+
+::
+
+    [key_n value_n left right] [value key [Tree-add] K] infra
+
+Expand ``K`` and evaluate a little:
+
+::
+
+    [key_n value_n left right] [value key [Tree-add] K] infra
+    [key_n value_n left right] [value key [Tree-add] cons cons dipdd] infra
+    [key_n value_n left right] [[value key Tree-add]           dipdd] infra
+
+Then, working backwards:
+
+::
+
+    [key_n value_n left right] [[value key Tree-add]           dipdd]      infra
+    [key_n value_n left right] [value key Tree-add]           [dipdd] cons infra
+    [key_n value_n left right] value key [Tree-add] cons cons [dipdd] cons infra
+
+And so ``T`` is just:
+
+::
+
+    T == cons cons [dipdd] cons infra
+
+.. code:: ipython2
+
+    define('T == cons cons [dipdd] cons infra')
+
+.. code:: ipython2
+
+    J('["old_k" "old_value" "left" "right"] "new_value" "new_key" ["Tree-add"] T')
+
+
+.. parsed-literal::
+
+    ['old_k' 'old_value' 'left' 'Tree-add' 'new_key' 'new_value' 'right']
+
+
+If the key we're adding is less than the node's key.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This is very very similar to the above:
+
+::
+
+    [key_n value_n left right] value key [Tree-add] E
+    [key_n value_n left right] value key [Tree-add] [P <] [Te] [Ee] ifte
+
+.. code:: ipython2
+
+    define('E == [P <] [Te] [Ee] ifte')
+
+In this case ``Te`` works that same as ``T`` but on the left child tree
+instead of the right, so the only difference is that it must use
+``dipd`` instead of ``dipdd``:
+
+::
+
+    Te == cons cons [dipd] cons infra
+
+.. code:: ipython2
+
+    define('Te == cons cons [dipd] cons infra')
+
+.. code:: ipython2
+
+    J('["old_k" "old_value" "left" "right"] "new_value" "new_key" ["Tree-add"] Te')
+
+
+.. parsed-literal::
+
+    ['old_k' 'old_value' 'Tree-add' 'new_key' 'new_value' 'left' 'right']
+
+
+Else the keys must be equal.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This means we must find:
+
+::
+
+       [key old_value left right] new_value key [Tree-add] Ee
+    ------------------------------------------------------------
+       [key new_value left right]
+
+This is another easy one:
+
+::
+
+    Ee == pop swap roll< rest rest cons cons
+
+Example:
+
+::
+
+    [key old_value left right] new_value key [Tree-add] pop swap roll< rest rest cons cons
+    [key old_value left right] new_value key                swap roll< rest rest cons cons
+    [key old_value left right] key new_value                     roll< rest rest cons cons
+    key new_value [key old_value left right]                           rest rest cons cons
+    key new_value [              left right]                                     cons cons
+                  [key new_value left right]
+
+.. code:: ipython2
+
+    define('Ee == pop swap roll< rest rest cons cons')
+
+.. code:: ipython2
+
+    J('["k" "old_value" "left" "right"] "new_value" "k" ["Tree-add"] Ee')
+
+
+.. parsed-literal::
+
+    ['k' 'new_value' 'left' 'right']
+
+
+Now we can define ``Tree-add``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+    Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec
+
+Putting it all together:
+
+::
+
+    Tree-new == swap [[] []] cons cons
+    P == pop roll> pop first
+    T == cons cons [dipdd] cons infra
+    Te == cons cons [dipd] cons infra
+    Ee == pop swap roll< rest rest cons cons
+    E == [P <] [Te] [Ee] ifte
+    R == [P >] [T] [E] ifte
+
+    Tree-add == [popop not] [[pop] dipd Tree-new] [] [R] genrec
+
+.. code:: ipython2
+
+    define('Tree-add == [popop not] [[pop] dipd Tree-new] [] [[P >] [T] [E] ifte] genrec')
+
+Examples
+~~~~~~~~
+
+.. code:: ipython2
+
+    J('[] 23 "b" Tree-add')  # Initial
+
+
+.. parsed-literal::
+
+    ['b' 23 [] []]
+
+
+.. code:: ipython2
+
+    J('["b" 23 [] []] 88 "c" Tree-add')  # Greater than
+
+
+.. parsed-literal::
+
+    ['b' 23 [] ['c' 88 [] []]]
+
+
+.. code:: ipython2
+
+    J('["b" 23 [] []] 88 "a" Tree-add')  # Less than
+
+
+.. parsed-literal::
+
+    ['b' 23 ['a' 88 [] []] []]
+
+
+.. code:: ipython2
+
+    J('["b" 23 [] []] 88 "b" Tree-add')  # Equal to
+
+
+.. parsed-literal::
+
+    ['b' 88 [] []]
+
+
+.. code:: ipython2
+
+    J('[] 23 "b" Tree-add 88 "a" Tree-add 44 "c" Tree-add')  # Series.
+
+
+.. parsed-literal::
+
+    ['b' 23 ['a' 88 [] []] ['c' 44 [] []]]
+
+
+.. code:: ipython2
+
+    J('[] [[23 "b"] [88 "a"] [44 "c"]] [i Tree-add] step')
+
+
+.. parsed-literal::
+
+    ['b' 23 ['a' 88 [] []] ['c' 44 [] []]]
+
+
+Interlude: ``cmp`` combinator
+-----------------------------
+
+Instead of mucking about with nested ``ifte`` combinators let's use
+``cmp`` which takes two values and three quoted programs on the stack
+and runs one of the three depending on the results of comparing the two
+values:
+
+::
+
+       a b [G] [E] [L] cmp
+    ------------------------- a > b
+            G
+
+       a b [G] [E] [L] cmp
+    ------------------------- a = b
+                E
+
+       a b [G] [E] [L] cmp
+    ------------------------- a < b
+                    L
+
+.. code:: ipython2
+
+    J("1 0 ['G'] ['E'] ['L'] cmp")
+
+
+.. parsed-literal::
+
+    'G'
+
+
+.. code:: ipython2
+
+    J("1 1 ['G'] ['E'] ['L'] cmp")
+
+
+.. parsed-literal::
+
+    'E'
+
+
+.. code:: ipython2
+
+    J("0 1 ['G'] ['E'] ['L'] cmp")
+
+
+.. parsed-literal::
+
+    'L'
+
+
+Redefine ``Tree-add``
+~~~~~~~~~~~~~~~~~~~~~
+
+We need a new non-destructive predicate ``P``:
+
+::
+
+       [node_key node_value left right] value key [Tree-add] P
+    ------------------------------------------------------------------------
+       [node_key node_value left right] value key [Tree-add] key node_key
+
+Let's start with ``over`` to get a copy of the key and then apply some
+function ``Q`` with the ``nullary`` combinator so it can dig out the
+node key (by throwing everything else away):
+
+::
+
+    P == over [Q] nullary
+
+    [node_key node_value left right] value key [Tree-add] over [Q] nullary
+    [node_key node_value left right] value key [Tree-add] key  [Q] nullary
+
+And ``Q`` would be:
+
+::
+
+    Q == popop popop first
+
+    [node_key node_value left right] value key [Tree-add] key Q
+    [node_key node_value left right] value key [Tree-add] key popop popop first
+    [node_key node_value left right] value key                      popop first
+    [node_key node_value left right]                                      first
+     node_key
+
+Or just:
+
+::
+
+    P == over [popop popop first] nullary
+
+.. code:: ipython2
+
+    define('P == over [popop popop first] nullary')
+
+Using ``cmp`` to simplify `our code above at
+``R1`` <#Adding-to-a-non-empty-node.>`__:
+
+::
+
+    [node_key node_value left right] value key [Tree-add] R1
+    [node_key node_value left right] value key [Tree-add] P [T] [E] [Te] cmp
+
+The line above becomes one of the three lines below:
+
+::
+
+    [node_key node_value left right] value key [Tree-add] T
+    [node_key node_value left right] value key [Tree-add] E
+    [node_key node_value left right] value key [Tree-add] Te
+
+The definition is a little longer but, I think, more elegant and easier
+to understand:
+
+::
+
+    Tree-add == [popop not] [[pop] dipd Tree-new] [] [P [T] [Ee] [Te] cmp] genrec
+
+.. code:: ipython2
+
+    define('Tree-add == [popop not] [[pop] dipd Tree-new] [] [P [T] [Ee] [Te] cmp] genrec')
+
+.. code:: ipython2
+
+    J('[] 23 "b" Tree-add 88 "a" Tree-add 44 "c" Tree-add')  # Still works.
+
+
+.. parsed-literal::
+
+    ['b' 23 ['a' 88 [] []] ['c' 44 [] []]]
+
+
+A Function to Traverse this Structure
+-------------------------------------
+
+Let's take a crack at writing a function that can recursively iterate or
+traverse these trees.
+
+Base case ``[]``
+~~~~~~~~~~~~~~~~
+
+The stopping predicate just has to detect the empty list:
+
+::
+
+    Tree-iter == [not] [E] [R0] [R1] genrec
+
+And since there's nothing at this node, we just ``pop`` it:
+
+::
+
+    Tree-iter == [not] [pop] [R0] [R1] genrec
+
+Node case ``[key value left right]``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now we need to figure out ``R0`` and ``R1``:
+
+::
+
+    Tree-iter == [not] [pop] [R0]           [R1] genrec
+              == [not] [pop] [R0 [Tree-iter] R1] ifte
+
+Let's look at it *in situ*:
+
+::
+
+    [key value left right] R0 [Tree-iter] R1
+
+Processing the current node.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``R0`` is almost certainly going to use ``dup`` to make a copy of the
+node and then ``dip`` on some function to process the copy with it:
+
+::
+
+    [key value left right] [F] dupdip                 [Tree-iter] R1
+    [key value left right]  F  [key value left right] [Tree-iter] R1
+
+For example, if we're getting all the keys ``F`` would be ``first``:
+
+::
+
+    R0 == [first] dupdip
+
+    [key value left right] [first] dupdip                 [Tree-iter] R1
+    [key value left right]  first  [key value left right] [Tree-iter] R1
+    key                            [key value left right] [Tree-iter] R1
+
+Recur
+^^^^^
+
+Now ``R1`` needs to apply ``[Tree-iter]`` to ``left`` and ``right``. If
+we drop the key and value from the node using ``rest`` twice we are left
+with an interesting situation:
+
+::
+
+    key [key value left right] [Tree-iter] R1
+    key [key value left right] [Tree-iter] [rest rest] dip
+    key [key value left right] rest rest [Tree-iter]
+    key [left right] [Tree-iter]
+
+Hmm, will ``step`` do?
+
+::
+
+    key [left right] [Tree-iter] step
+    key left Tree-iter [right] [Tree-iter] step
+    key left-keys [right] [Tree-iter] step
+    key left-keys right Tree-iter
+    key left-keys right-keys
+
+Neat. So:
+
+::
+
+    R1 == [rest rest] dip step
+
+Putting it together
+~~~~~~~~~~~~~~~~~~~
+
+We have:
+
+::
+
+    Tree-iter == [not] [pop] [[F] dupdip] [[rest rest] dip step] genrec
+
+When I was reading this over I realized ``rest rest`` could go in
+``R0``:
+
+::
+
+    Tree-iter == [not] [pop] [[F] dupdip rest rest] [step] genrec
+
+(And ``[step] genrec`` is such a cool and suggestive combinator!)
+
+Parameterizing the ``F`` per-node processing function.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+                    [F] Tree-iter
+    ------------------------------------------------------
+       [not] [pop] [[F] dupdip rest rest] [step] genrec
+
+Working backward:
+
+::
+
+    [not] [pop] [[F] dupdip rest rest]            [step] genrec
+    [not] [pop] [F]       [dupdip rest rest] cons [step] genrec
+    [F] [not] [pop] roll< [dupdip rest rest] cons [step] genrec
+
+``Tree-iter``
+~~~~~~~~~~~~~
+
+::
+
+    Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec
+
+.. code:: ipython2
+
+    define('Tree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec')
+
+Examples
+~~~~~~~~
+
+.. code:: ipython2
+
+    J('[] [foo] Tree-iter')  #  It doesn't matter what F is as it won't be used.
+
+
+.. parsed-literal::
+
+    
+
+
+.. code:: ipython2
+
+    J("['b' 23 ['a' 88 [] []] ['c' 44 [] []]] [first] Tree-iter")
+
+
+.. parsed-literal::
+
+    'b' 'a' 'c'
+
+
+.. code:: ipython2
+
+    J("['b' 23 ['a' 88 [] []] ['c' 44 [] []]] [second] Tree-iter")
+
+
+.. parsed-literal::
+
+    23 88 44
+
+
+Interlude: A Set-like Datastructure
+-----------------------------------
+
+We can use this to make a set-like datastructure by just setting values
+to e.g. 0 and ignoring them. It's set-like in that duplicate items added
+to it will only occur once within it, and we can query it in
+`:math:`O(\log_2 N)` <https://en.wikipedia.org/wiki/Binary_search_tree#cite_note-2>`__
+time.
+
+.. code:: ipython2
+
+    J('[] [3 9 5 2 8 6 7 8 4] [0 swap Tree-add] step')
+
+
+.. parsed-literal::
+
+    [3 0 [2 0 [] []] [9 0 [5 0 [4 0 [] []] [8 0 [6 0 [] [7 0 [] []]] []]] []]]
+
+
+.. code:: ipython2
+
+    define('to_set == [] swap [0 swap Tree-add] step')
+
+.. code:: ipython2
+
+    J('[3 9 5 2 8 6 7 8 4] to_set')
+
+
+.. parsed-literal::
+
+    [3 0 [2 0 [] []] [9 0 [5 0 [4 0 [] []] [8 0 [6 0 [] [7 0 [] []]] []]] []]]
+
+
+And with that we can write a little program ``unique`` to remove
+duplicate items from a list.
+
+.. code:: ipython2
+
+    define('unique == [to_set [first] Tree-iter] cons run')
+
+.. code:: ipython2
+
+    J('[3 9 3 5 2 9 8 8 8 6 2 7 8 4 3] unique')  # Filter duplicate items.
+
+
+.. parsed-literal::
+
+    [7 6 8 4 5 9 2 3]
+
+
+A Version of ``Tree-iter`` that does In-Order Traversal
+-------------------------------------------------------
+
+If you look back to the `non-empty case of the ``Tree-iter``
+function <#Node-case-%5Bkey-value-left-right%5D>`__ we can design a
+variant that first processes the left child, then the current node, then
+the right child. This will allow us to traverse the tree in sort order.
+
+::
+
+    Tree-iter-order == [not] [pop] [R0] [R1] genrec
+
+To define ``R0`` and ``R1`` it helps to look at them as they will appear
+when they run:
+
+::
+
+    [key value left right] R0 [BTree-iter-order] R1
+
+Process the left child.
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Staring at this for a bit suggests ``dup third`` to start:
+
+::
+
+    [key value left right] R0        [Tree-iter-order] R1
+    [key value left right] dup third [Tree-iter-order] R1
+    [key value left right] left      [Tree-iter-order] R1
+
+Now maybe:
+
+::
+
+    [key value left right] left [Tree-iter-order] [cons dip] dupdip
+    [key value left right] left [Tree-iter-order]  cons dip [Tree-iter-order]
+    [key value left right] [left Tree-iter-order]       dip [Tree-iter-order]
+    left Tree-iter-order [key value left right]             [Tree-iter-order]
+
+Process the current node.
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+So far, so good. Now we need to process the current node's values:
+
+::
+
+    left Tree-iter-order [key value left right] [Tree-iter-order] [[F] dupdip] dip
+    left Tree-iter-order [key value left right] [F] dupdip [Tree-iter-order]
+    left Tree-iter-order [key value left right] F [key value left right] [Tree-iter-order]
+
+If ``F`` needs items from the stack below the left stuff it should have
+``cons``'d them before beginning maybe? For functions like ``first`` it
+works fine as-is.
+
+::
+
+    left Tree-iter-order [key value left right] first [key value left right] [Tree-iter-order]
+    left Tree-iter-order key [key value left right] [Tree-iter-order]
+
+Process the right child.
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+First ditch the rest of the node and get the right child:
+
+::
+
+    left Tree-iter-order key [key value left right] [Tree-iter-order] [rest rest rest first] dip
+    left Tree-iter-order key right [Tree-iter-order]
+
+Then, of course, we just need ``i`` to run ``Tree-iter-order`` on the
+right side:
+
+::
+
+    left Tree-iter-order key right [Tree-iter-order] i
+    left Tree-iter-order key right Tree-iter-order
+
+Defining ``Tree-iter-order``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The result is a little awkward:
+
+::
+
+    R1 == [cons dip] dupdip [[F] dupdip] dip [rest rest rest first] dip i
+
+Let's do a little semantic factoring:
+
+::
+
+    fourth == rest rest rest first
+
+    proc_left == [cons dip] dupdip
+    proc_current == [[F] dupdip] dip
+    proc_right == [fourth] dip i
+
+    Tree-iter-order == [not] [pop] [dup third] [proc_left proc_current proc_right] genrec
+
+Now we can sort sequences.
+
+.. code:: ipython2
+
+    #define('Tree-iter-order == [not] [pop] [dup third] [[cons dip] dupdip [[first] dupdip] dip [rest rest rest first] dip i] genrec')
+    
+    
+    DefinitionWrapper.add_definitions('''
+    
+    fourth == rest rest rest first
+    
+    proc_left == [cons dip] dupdip
+    proc_current == [[first] dupdip] dip
+    proc_right == [fourth] dip i
+    
+    Tree-iter-order == [not] [pop] [dup third] [proc_left proc_current proc_right] genrec
+    
+    ''', D)
+    
+    
+
+
+.. code:: ipython2
+
+    J('[3 9 5 2 8 6 7 8 4] to_set Tree-iter-order')
+
+
+.. parsed-literal::
+
+    2 3 4 5 6 7 8 9
+
+
+Parameterizing the ``[F]`` function is left as an exercise for the
+reader.
+
+Getting values by key
+---------------------
+
+Let's derive a function that accepts a tree and a key and returns the
+value associated with that key.
+
+::
+
+       tree key Tree-get
+    -----------------------
+            value
+
+But what do we do if the key isn't in the tree? In Python we might raise
+a ``KeyError`` but I'd like to avoid exceptions in Joy if possible, and
+here I think it's possible. (Division by zero is an example of where I
+think it's probably better to let Python crash Joy. Sometimes the
+machinery fails and you have to "stop the line", I think.)
+
+Let's pass the buck to the caller by making the base case a given, you
+have to decide for yourself what ``[E]`` should be.
+
+::
+
+       tree key [E] Tree-get
+    ---------------------------- key in tree
+               value
+
+       tree key [E] Tree-get
+    ---------------------------- key not in tree
+             [] key E
+
+The base case ``[]``
+~~~~~~~~~~~~~~~~~~~~
+
+As before, the stopping predicate just has to detect the empty list:
+
+::
+
+    Tree-get == [pop not] [E] [R0] [R1] genrec
+
+So we define:
+
+::
+
+    Tree-get == [pop not] swap [R0] [R1] genrec
+
+Note that this ``Tree-get`` creates a slightly different function than
+itself and *that function* does the actual recursion. This kind of
+higher-level programming is unusual in most languages but natural in
+Joy.
+
+::
+
+    tree key [E] [pop not] swap [R0] [R1] genrec
+    tree key [pop not] [E] [R0] [R1] genrec
+
+The anonymous specialized recursive function that will do the real work.
+
+::
+
+    [pop not] [E] [R0] [R1] genrec
+
+Node case ``[key value left right]``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now we need to figure out ``R0`` and ``R1``:
+
+::
+
+    [key value left right] key R0 [BTree-get] R1
+
+We want to compare the search key with the key in the node, and if they
+are the same return the value, otherwise recur on one of the child
+nodes. So it's very similar to the above funtion, with ``[R0] == []``
+and ``R1 == P [T>] [E] [T<] cmp``:
+
+::
+
+    [key value left right] key [BTree-get] P [T>] [E] [T<] cmp
+
+Predicate
+^^^^^^^^^
+
+::
+
+    P == over [get-node-key] nullary
+    get-node-key == pop popop first
+
+The only difference is that ``get-node-key`` does one less ``pop``
+because there's no value to discard.
+
+Branches
+^^^^^^^^
+
+Now we have to derive the branches:
+
+::
+
+    [key_n value_n left right] key [BTree-get] T>
+    [key_n value_n left right] key [BTree-get] E
+    [key_n value_n left right] key [BTree-get] T<
+
+Greater than and less than
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The cases of ``T>`` and ``T<`` are similar to above but instead of using
+``infra`` we have to discard the rest of the structure:
+
+::
+
+       [key_n value_n left right] key [BTree-get] T>
+    ---------------------------------------------------
+                           right  key  BTree-get
+
+And:
+
+::
+
+       [key_n value_n left right] key [BTree-get] T<
+    ---------------------------------------------------
+                      left        key  BTree-get
+
+So:
+
+::
+
+    T> == [fourth] dipd i
+    T< == [third] dipd i
+
+E.g.:
+
+::
+
+    [key_n value_n left right]        key [BTree-get] [fourth] dipd i
+    [key_n value_n left right] fourth key [BTree-get]               i
+                        right         key [BTree-get]               i
+                        right         key  BTree-get
+
+Equal keys
+^^^^^^^^^^
+
+Return the node's value:
+
+::
+
+    [key_n value_n left right] key [BTree-get] E == value_n
+
+    E == popop second
+
+``Tree-get``
+~~~~~~~~~~~~
+
+So:
+
+::
+
+    fourth == rest rest rest first
+    get-node-key == pop popop first
+    P == over [get-node-key] nullary
+    T> == [fourth] dipd i
+    T< == [third] dipd i
+    E == popop second
+
+    Tree-get == [pop not] swap [] [P [T>] [E] [T<] cmp] genrec
+
+.. code:: ipython2
+
+    # I don't want to deal with name conflicts with the above so I'm inlining everything here.
+    # The original Joy system has "hide" which is a meta-command which allows you to use named
+    # definitions that are only in scope for a given definition.  I don't want to implement
+    # that (yet) so...
+    
+    
+    define('''
+    Tree-get == [pop not] swap [] [
+      over [pop popop first] nullary
+      [[fourth] dipd i]
+      [popop second]
+      [[third] dipd i]
+      cmp
+      ] genrec
+    ''')
+
+.. code:: ipython2
+
+    J('["gary" 23 [] []] "mike" [popd " not in tree" +] Tree-get')
+
+
+.. parsed-literal::
+
+    'mike not in tree'
+
+
+.. code:: ipython2
+
+    J('["gary" 23 [] []] "gary" [popop "err"] Tree-get')
+
+
+.. parsed-literal::
+
+    23
+
+
+.. code:: ipython2
+
+    J('''
+    
+        [] [[0 'a'] [1 'b'] [2 'c']] [i Tree-add] step
+    
+        'c' [popop 'not found'] Tree-get
+    
+    ''')
+
+
+.. parsed-literal::
+
+    2
+
+
+.. code:: ipython2
+
+    J('''
+    
+        [] [[0 'a'] [1 'b'] [2 'c']] [i Tree-add] step
+    
+        'd' [popop 'not found'] Tree-get
+    
+    ''')
+
+
+.. parsed-literal::
+
+    'not found'
+
+
+Tree-delete
+-----------
+
+Now let's write a function that can return a tree datastructure with a
+key, value pair deleted:
+
+::
+
+       tree key Tree-delete
+    ---------------------------
+              tree
+
+If the key is not in tree it just returns the tree unchanged.
+
+Base case
+~~~~~~~~~
+
+Same as above.
+
+::
+
+    Tree-Delete == [pop not] [pop] [R0] [R1] genrec
+
+Recur
+~~~~~
+
+Now we get to figure out the recursive case. We need the node's key to
+compare and we need to carry the key into recursive branches. Let ``D``
+be shorthand for ``Tree-Delete``:
+
+::
+
+    D == Tree-Delete == [pop not] [pop] [R0] [R1] genrec
+
+    [node_key node_value left right] key R0                   [D] R1
+    [node_key node_value left right] key over  first swap dup [D] cons R1′
+    [node_key node_value left right] key [...] first swap dup [D] cons R1′
+    [node_key node_value left right] key node_key    swap dup [D] cons R1′
+    [node_key node_value left right] node_key key         dup [D] cons R1′
+    [node_key node_value left right] node_key key key         [D] cons R1′
+    [node_key node_value left right] node_key key         [key D]      R1′
+
+And then:
+
+::
+
+    [node_key node_value left right] node_key key [key D] R1′
+    [node_key node_value left right] node_key key [key D] roll> [T>] [E] [T<] cmp
+    [node_key node_value left right] node_key key [key D] roll> [T>] [E] [T<] cmp
+    [node_key node_value left right] [key D] node_key key       [T>] [E] [T<] cmp
+
+So:
+
+::
+
+    R0 == over first swap dup
+    R1 == cons roll> [T>] [E] [T<] cmp
+
+Compare Keys
+~~~~~~~~~~~~
+
+The last line above:
+
+::
+
+    [node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp
+
+Then becomes one of these three:
+
+::
+
+    [node_key node_value left right] [key D] T>
+    [node_key node_value left right] [key D] E
+    [node_key node_value left right] [key D] T<
+
+Greater than case and less than case
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+       [node_key node_value left right] [F] T>
+    -------------------------------------------------
+       [node_key node_value (left F) right]
+
+
+       [node_key node_value left right] [F] T<
+    -------------------------------------------------
+       [node_key node_value left (right F)]
+
+First, treating the node as a stack:
+
+::
+
+    right left       node_value node_key [key D] dipd
+    right left key D node_value node_key
+    right left'      node_value node_key
+
+Ergo:
+
+::
+
+    [node_key node_value left right] [key D] [dipd] cons infra
+
+So:
+
+::
+
+    T> == [dipd] cons infra
+    T< == [dipdd] cons infra
+
+The else case
+~~~~~~~~~~~~~
+
+We have found the node in the tree where ``key`` equals ``node_key``. We
+need to replace the current node with something
+
+::
+
+       [node_key node_value left right] [key D] E
+    ------------------------------------------------
+                        tree
+
+We have to handle three cases, so let's use ``cond``.
+
+One or more child nodes are ``[]``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The first two cases are symmetrical: if we only have one non-empty child
+node return it. If both child nodes are empty return an empty node.
+
+::
+
+    E == [
+        [[pop third not] pop fourth]
+        [[pop fourth not] pop third]
+        [default]
+    ] cond
+
+Both child nodes are non-empty.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If both child nodes are non-empty, we find the highest node in our lower
+sub-tree, take its key and value to replace (delete) our own, then get
+rid of it by recursively calling delete() on our lower sub-node with our
+new key.
+
+(We could also find the lowest node in our higher sub-tree and take its
+key and value and delete it. I only implemented one of these two
+symmetrical options. Over a lot of deletions this might make the tree
+more unbalanced. Oh well.)
+
+The initial structure of the default function:
+
+::
+
+    default == [E′] cons infra
+
+    [node_key node_value left right] [key D] default
+    [node_key node_value left right] [key D] [E′] cons infra
+    [node_key node_value left right] [[key D] E′]      infra
+
+    right left node_value node_key [key D] E′
+
+First things first, we no longer need this node's key and value:
+
+::
+
+    right left node_value node_key [key D] roll> popop E″
+    right left [key D] node_value node_key       popop E″
+    right left [key D]                                 E″
+
+We have to we find the highest (right-most) node in our lower (left) sub-tree:
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+::
+
+    right left [key D] E″
+
+Ditch the key:
+
+::
+
+    right left [key D] rest E‴
+    right left     [D]      E‴
+
+Find the right-most node:
+
+::
+
+    right left        [D] [dup W] dip E⁗
+    right left dup  W [D]             E⁗
+    right left left W [D]             E⁗
+
+Consider:
+
+::
+
+    left W
+
+We know left is not empty:
+
+::
+
+    [L_key L_value L_left L_right] W
+
+We want to keep extracting the right node as long as it is not empty:
+
+::
+
+    W.rightmost == [P] [B] while
+
+    left W.rightmost W′
+
+The predicate:
+
+::
+
+    [L_key L_value L_left L_right] P
+    [L_key L_value L_left L_right] fourth
+                          L_right
+
+This can run on ``[]`` so must be guarded:
+
+::
+
+    ?fourth ==  [] [fourth] [] ifte
+
+( if\_not\_empty == [] swap [] ifte ?fourth == [fourth] if\_not\_empty )
+
+The body is just ``fourth``:
+
+::
+
+    left [?fourth] [fourth] while W′
+    rightest                      W′
+
+So:
+
+::
+
+    W.rightmost == [?fourth] [fourth] while
+
+Found right-most node in our left sub-tree
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We know rightest is not empty:
+
+::
+
+    [R_key R_value R_left R_right] W′
+    [R_key R_value R_left R_right] W′
+    [R_key R_value R_left R_right] uncons uncons pop
+    R_key [R_value R_left R_right]        uncons pop
+    R_key R_value [R_left R_right]               pop
+    R_key R_value
+
+So:
+
+::
+
+    W == [?fourth] [fourth] while uncons uncons pop
+
+And:
+
+::
+
+    right left left W        [D] E⁗
+    right left R_key R_value [D] E⁗
+
+Replace current node key and value, recursively delete rightmost
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Final stretch. We want to end up with something like:
+
+::
+
+    right left [R_key D] i R_value R_key
+    right left  R_key D    R_value R_key
+    right left′            R_value R_key
+
+If we adjust our definition of ``W`` to include ``over`` at the end:
+
+::
+
+    W == [fourth] [fourth] while uncons uncons pop over
+
+That will give us:
+
+::
+
+    right left R_key R_value R_key [D] E⁗
+
+    right left         R_key R_value R_key [D] cons dipd E⁗′
+    right left         R_key R_value [R_key D]      dipd E⁗′
+    right left R_key D R_key R_value                     E⁗′
+    right left′        R_key R_value                     E⁗′
+    right left′        R_key R_value                     swap
+    right left′ R_value R_key
+
+So:
+
+::
+
+    E′ == roll> popop E″
+
+    E″ == rest E‴
+
+    E‴ == [dup W] dip E⁗
+
+    E⁗ == cons dipdd swap
+
+Substituting:
+
+::
+
+    W == [fourth] [fourth] while uncons uncons pop over
+    E′ == roll> popop rest [dup W] dip cons dipd swap
+    E == [
+        [[pop third not] pop fourth]
+        [[pop fourth not] pop third]
+        [[E′] cons infra]
+    ] cond
+
+Minor rearrangement, move ``dup`` into ``W``:
+
+::
+
+    W == dup [fourth] [fourth] while uncons uncons pop over
+    E′ == roll> popop rest [W] dip cons dipd swap
+    E == [
+        [[pop third not] pop fourth]
+        [[pop fourth not] pop third]
+        [[E′] cons infra]
+    ] cond
+
+Refactoring
+~~~~~~~~~~~
+
+::
+
+    W.rightmost == [fourth] [fourth] while
+    W.unpack == uncons uncons pop
+    W == dup W.rightmost W.unpack over
+    E.clear_stuff == roll> popop rest
+    E.delete == cons dipd
+    E.0 == E.clear_stuff [W] dip E.delete swap
+    E == [
+        [[pop third not] pop fourth]
+        [[pop fourth not] pop third]
+        [[E.0] cons infra]
+    ] cond
+    T> == [dipd] cons infra
+    T< == [dipdd] cons infra
+    R0 == over first swap dup
+    R1 == cons roll> [T>] [E] [T<] cmp
+    BTree-Delete == [pop not] swap [R0] [R1] genrec
+
+By the standards of the code I've written so far, this is a *huge* Joy
+program.
+
+.. code:: ipython2
+
+    DefinitionWrapper.add_definitions('''
+    first_two == uncons uncons pop
+    fourth == rest rest rest first
+    ?fourth == [] [fourth] [] ifte
+    W.rightmost == [?fourth] [fourth] while
+    E.clear_stuff == roll> popop rest
+    E.delete == cons dipd
+    W == dup W.rightmost first_two over
+    E.0 == E.clear_stuff [W] dip E.delete swap
+    E == [[[pop third not] pop fourth] [[pop fourth not] pop third] [[E.0] cons infra]] cond
+    T> == [dipd] cons infra
+    T< == [dipdd] cons infra
+    R0 == over first swap dup
+    R1 == cons roll> [T>] [E] [T<] cmp
+    Tree-Delete == [pop not] [pop] [R0] [R1] genrec
+    ''', D)
+
+.. code:: ipython2
+
+    J("['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'c' Tree-Delete ")
+
+
+.. parsed-literal::
+
+    ['a' 23 [] ['b' 88 [] []]]
+
+
+.. code:: ipython2
+
+    J("['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'b' Tree-Delete ")
+
+
+.. parsed-literal::
+
+    ['a' 23 [] ['c' 44 [] []]]
+
+
+.. code:: ipython2
+
+    J("['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'a' Tree-Delete ")
+
+
+.. parsed-literal::
+
+    ['b' 88 [] ['c' 44 [] []]]
+
+
+.. code:: ipython2
+
+    J("['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'der' Tree-Delete ")
+
+
+.. parsed-literal::
+
+    ['a' 23 [] ['b' 88 [] ['c' 44 [] []]]]
+
+
+.. code:: ipython2
+
+    J('[] [4 2 3 1 6 7 5 ] [0 swap Tree-add] step')
+
+
+.. parsed-literal::
+
+    [4 0 [2 0 [1 0 [] []] [3 0 [] []]] [6 0 [5 0 [] []] [7 0 [] []]]]
+
+
+.. code:: ipython2
+
+    J("[4 0 [2 0 [1 0 [] []] [3 0 [] []]] [6 0 [5 0 [] []] [7 0 [] []]]] 3 Tree-Delete ")
+
+
+.. parsed-literal::
+
+    [4 0 [2 0 [1 0 [] []] []] [6 0 [5 0 [] []] [7 0 [] []]]]
+
+
+.. code:: ipython2
+
+    J("[4 0 [2 0 [1 0 [] []] [3 0 [] []]] [6 0 [5 0 [] []] [7 0 [] []]]] 4 Tree-Delete ")
+
+
+.. parsed-literal::
+
+    [3 0 [2 0 [1 0 [] []] []] [6 0 [5 0 [] []] [7 0 [] []]]]
+
+
+Appendix: The source code.
+--------------------------
+
+::
+
+    fourth == rest_two rest first
+    ?fourth == [] [fourth] [] ifte
+    first_two == uncons uncons pop
+    ccons == cons cons
+    cinf == cons infra
+    rest_two == rest rest
+
+    _Tree_T> == [dipd] cinf
+    _Tree_T< == [dipdd] cinf
+
+    _Tree_add_P == over [popop popop first] nullary
+    _Tree_add_T> == ccons _Tree_T<
+    _Tree_add_T< == ccons _Tree_T>
+    _Tree_add_Ee == pop swap roll< rest_two ccons
+    _Tree_add_R == _Tree_add_P [_Tree_add_T>] [_Tree_add_Ee] [_Tree_add_T<] cmp
+    _Tree_add_E == [pop] dipd Tree-new
+
+    _Tree_iter_order_left == [cons dip] dupdip
+    _Tree_iter_order_current == [[F] dupdip] dip
+    _Tree_iter_order_right == [fourth] dip i
+    _Tree_iter_order_R == _Tree_iter_order_left _Tree_iter_order_current _Tree_iter_order_right
+
+    _Tree_get_P == over [pop popop first] nullary
+    _Tree_get_T> == [fourth] dipd i
+    _Tree_get_T< == [third] dipd i
+    _Tree_get_E == popop second
+    _Tree_get_R == _Tree_get_P [_Tree_get_T>] [_Tree_get_E] [_Tree_get_T<] cmp
+
+    _Tree_delete_rightmost == [?fourth] [fourth] while
+    _Tree_delete_clear_stuff == roll> popop rest
+    _Tree_delete_del == dip cons dipd swap
+    _Tree_delete_W == dup _Tree_delete_rightmost first_two over
+    _Tree_delete_E.0 == _Tree_delete_clear_stuff [_Tree_delete_W] _Tree_delete_del
+    _Tree_delete_E == [[[pop third not] pop fourth] [[pop fourth not] pop third] [[_Tree_delete_E.0] cinf]] cond
+    _Tree_delete_R0 == over first swap dup
+    _Tree_delete_R1 == cons roll> [_Tree_T>] [_Tree_delete_E] [_Tree_T<] cmp
+
+    Tree-new == swap [[] []] ccons
+    Tree-add == [popop not] [_Tree_add_E] [] [_Tree_add_R] genrec
+    Tree-iter == [not] [pop] roll< [dupdip rest_two] cons [step] genrec
+    Tree-iter-order == [not] [pop] [dup third] [_Tree_iter_order_R] genrec
+    Tree-get == [pop not] swap [] [_Tree_get_R] genrec
+    Tree-delete == [pop not] [pop] [_Tree_delete_R0] [_Tree_delete_R1] genrec
diff --git a/docs/sphinx_docs/notebooks/Treestep.rst b/docs/sphinx_docs/notebooks/Treestep.rst
new file mode 100644
index 0000000..a693d60
--- /dev/null
+++ b/docs/sphinx_docs/notebooks/Treestep.rst
@@ -0,0 +1,621 @@
+
+Treating Trees II: ``treestep``
+===============================
+
+Let's consider a tree structure, similar to one described `"Why
+functional programming matters" by John
+Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__,
+that consists of a node value followed by zero or more child trees. (The
+asterisk is meant to indicate the `Kleene
+star <https://en.wikipedia.org/wiki/Kleene_star>`__.)
+
+::
+
+    tree = [] | [node tree*]
+
+In the spirit of ``step`` we are going to define a combinator
+``treestep`` which expects a tree and three additional items: a
+base-case function ``[B]``, and two quoted programs ``[N]`` and ``[C]``.
+
+::
+
+    tree [B] [N] [C] treestep
+
+If the current tree node is empty then just execute ``B``:
+
+::
+
+       [] [B] [N] [C] treestep
+    ---------------------------
+       []  B
+
+Otherwise, evaluate ``N`` on the node value, ``map`` the whole function
+(abbreviated here as ``K``) over the child trees recursively, and then
+combine the result with ``C``.
+
+::
+
+       [node tree*] [B] [N] [C] treestep
+    --------------------------------------- w/ K == [B] [N] [C] treestep
+           node N [tree*] [K] map C
+
+(Later on we'll experiment with making ``map`` part of ``C`` so you can
+use other combinators.)
+
+Derive the recursive function.
+------------------------------
+
+We can begin to derive it by finding the ``ifte`` stage that ``genrec``
+will produce.
+
+::
+
+    K == [not] [B] [R0]   [R1] genrec
+      == [not] [B] [R0 [K] R1] ifte
+
+So we just have to derive ``J``:
+
+::
+
+    J == R0 [K] R1
+
+The behavior of ``J`` is to accept a (non-empty) tree node and arrive at
+the desired outcome.
+
+::
+
+           [node tree*] J
+    ------------------------------
+       node N [tree*] [K] map C
+
+So ``J`` will have some form like:
+
+::
+
+    J == ... [N] ... [K] ... [C] ...
+
+Let's dive in. First, unquote the node and ``dip`` ``N``.
+
+::
+
+    [node tree*] uncons [N] dip
+    node [tree*]        [N] dip
+    node N [tree*]
+
+Next, ``map`` ``K`` over the child trees and combine with ``C``.
+
+::
+
+    node N [tree*] [K] map C
+    node N [tree*] [K] map C
+    node N [K.tree*]       C
+
+So:
+
+::
+
+    J == uncons [N] dip [K] map C
+
+Plug it in and convert to ``genrec``:
+
+::
+
+    K == [not] [B] [J                       ] ifte
+      == [not] [B] [uncons [N] dip [K] map C] ifte
+      == [not] [B] [uncons [N] dip]   [map C] genrec
+
+Extract the givens to parameterize the program.
+-----------------------------------------------
+
+Working backwards:
+
+::
+
+    [not] [B]          [uncons [N] dip]                  [map C] genrec
+    [B] [not] swap     [uncons [N] dip]                  [map C] genrec
+    [B]                [uncons [N] dip] [[not] swap] dip [map C] genrec
+                                        ^^^^^^^^^^^^^^^^
+    [B] [[N] dip]      [uncons] swoncat [[not] swap] dip [map C] genrec
+    [B] [N] [dip] cons [uncons] swoncat [[not] swap] dip [map C] genrec
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Extract a couple of auxiliary definitions:
+
+::
+
+    TS.0 == [[not] swap] dip
+    TS.1 == [dip] cons [uncons] swoncat
+
+::
+
+    [B] [N] TS.1 TS.0 [map C]                         genrec
+    [B] [N]           [map C]         [TS.1 TS.0] dip genrec
+    [B] [N] [C]         [map] swoncat [TS.1 TS.0] dip genrec
+
+The givens are all to the left so we have our definition.
+
+(alternate) Extract the givens to parameterize the program.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Working backwards:
+
+::
+
+    [not] [B]           [uncons [N] dip]            [map C] genrec
+    [not] [B] [N]       [dip] cons [uncons] swoncat [map C] genrec
+    [B] [N] [not] roll> [dip] cons [uncons] swoncat [map C] genrec
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Define ``treestep``
+-------------------
+
+.. code:: ipython2
+
+    from notebook_preamble import D, J, V, define, DefinitionWrapper
+
+.. code:: ipython2
+
+    DefinitionWrapper.add_definitions('''
+    
+        _treestep_0 == [[not] swap] dip
+        _treestep_1 == [dip] cons [uncons] swoncat
+        treegrind == [_treestep_1 _treestep_0] dip genrec
+        treestep == [map] swoncat treegrind
+    
+    ''', D)
+
+Examples
+--------
+
+Consider trees, the nodes of which are integers. We can find the sum of
+all nodes in a tree with this function:
+
+::
+
+    sumtree == [pop 0] [] [sum +] treestep
+
+.. code:: ipython2
+
+    define('sumtree == [pop 0] [] [sum +] treestep')
+
+Running this function on an empty tree value gives zero:
+
+::
+
+       [] [pop 0] [] [sum +] treestep
+    ------------------------------------
+               0
+
+.. code:: ipython2
+
+    J('[] sumtree')  # Empty tree.
+
+
+.. parsed-literal::
+
+    0
+
+
+Running it on a non-empty node:
+
+::
+
+    [n tree*]  [pop 0] [] [sum +] treestep
+    n [tree*] [[pop 0] [] [sum +] treestep] map sum +
+    n [ ... ]                                   sum +
+    n m                                             +
+    n+m
+
+.. code:: ipython2
+
+    J('[23] sumtree')  # No child trees.
+
+
+.. parsed-literal::
+
+    23
+
+
+.. code:: ipython2
+
+    J('[23 []] sumtree')  # Child tree, empty.
+
+
+.. parsed-literal::
+
+    23
+
+
+.. code:: ipython2
+
+    J('[23 [2 [4]] [3]] sumtree')  # Non-empty child trees.
+
+
+.. parsed-literal::
+
+    32
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] sumtree')  # Etc...
+
+
+.. parsed-literal::
+
+    49
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] [pop 0] [] [cons sum] treestep')  # Alternate "spelling".
+
+
+.. parsed-literal::
+
+    49
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] [] [pop 23] [cons] treestep')  # Replace each node.
+
+
+.. parsed-literal::
+
+    [23 [23 [23] [23]] [23] [23 []]]
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep')
+
+
+.. parsed-literal::
+
+    [1 [1 [1] [1]] [1] [1 []]]
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep sumtree')
+
+
+.. parsed-literal::
+
+    6
+
+
+.. code:: ipython2
+
+    J('[23 [2 [8] [9]] [3] [4 []]] [pop 0] [pop 1] [sum +] treestep')  # Combine replace and sum into one function.
+
+
+.. parsed-literal::
+
+    6
+
+
+.. code:: ipython2
+
+    J('[4 [3 [] [7]]] [pop 0] [pop 1] [sum +] treestep')  # Combine replace and sum into one function.
+
+
+.. parsed-literal::
+
+    3
+
+
+Redefining the Ordered Binary Tree in terms of ``treestep``.
+------------------------------------------------------------
+
+::
+
+    Tree = [] | [[key value] left right]
+
+What kind of functions can we write for this with our ``treestep``?
+
+The pattern for processing a non-empty node is:
+
+::
+
+    node N [tree*] [K] map C
+
+Plugging in our BTree structure:
+
+::
+
+    [key value] N [left right] [K] map C
+
+Traversal
+~~~~~~~~~
+
+::
+
+    [key value] first [left right] [K] map i
+    key [value]       [left right] [K] map i
+    key               [left right] [K] map i
+    key               [lkey rkey ]         i
+    key                lkey rkey
+
+This doesn't quite work:
+
+.. code:: ipython2
+
+    J('[[3 0] [[2 0] [][]] [[9 0] [[5 0] [[4 0] [][]] [[8 0] [[6 0] [] [[7 0] [][]]][]]][]]] ["B"] [first] [i] treestep')
+
+
+.. parsed-literal::
+
+    3 'B' 'B'
+
+
+Doesn't work because ``map`` extracts the ``first`` item of whatever its
+mapped function produces. We have to return a list, rather than
+depositing our results directly on the stack.
+
+::
+
+    [key value] N     [left right] [K] map C
+
+    [key value] first [left right] [K] map flatten cons
+    key               [left right] [K] map flatten cons
+    key               [[lk] [rk] ]         flatten cons
+    key               [ lk   rk  ]                 cons
+                      [key  lk   rk  ]
+
+So:
+
+::
+
+    [] [first] [flatten cons] treestep
+
+.. code:: ipython2
+
+    J('[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]]   [] [first] [flatten cons] treestep')
+
+
+.. parsed-literal::
+
+    [3 2 9 5 4 8 6 7]
+
+
+There we go.
+
+In-order traversal
+~~~~~~~~~~~~~~~~~~
+
+From here:
+
+::
+
+    key [[lk] [rk]] C
+    key [[lk] [rk]] i
+    key  [lk] [rk] roll<
+    [lk] [rk] key swons concat
+    [lk] [key rk]       concat
+    [lk   key rk]
+
+So:
+
+::
+
+    [] [i roll< swons concat] [first] treestep
+
+.. code:: ipython2
+
+    J('[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]]   [] [uncons pop] [i roll< swons concat] treestep')
+
+
+.. parsed-literal::
+
+    [2 3 4 5 6 7 8 9]
+
+
+With ``treegrind``?
+-------------------
+
+The ``treegrind`` function doesn't include the ``map`` combinator, so
+the ``[C]`` function must arrange to use some combinator on the quoted
+recursive copy ``[K]``. With this function, the pattern for processing a
+non-empty node is:
+
+::
+
+    node N [tree*] [K] C
+
+Plugging in our BTree structure:
+
+::
+
+    [key value] N [left right] [K] C
+
+.. code:: ipython2
+
+    J('[["key" "value"] ["left"] ["right"] ] ["B"] ["N"] ["C"] treegrind')
+
+
+.. parsed-literal::
+
+    ['key' 'value'] 'N' [['left'] ['right']] [[not] ['B'] [uncons ['N'] dip] ['C'] genrec] 'C'
+
+
+``treegrind`` with ``step``
+---------------------------
+
+Iteration through the nodes
+
+.. code:: ipython2
+
+    J('[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]]   [pop] ["N"] [step] treegrind')
+
+
+.. parsed-literal::
+
+    [3 0] 'N' [2 0] 'N' [9 0] 'N' [5 0] 'N' [4 0] 'N' [8 0] 'N' [6 0] 'N' [7 0] 'N'
+
+
+Sum the nodes' keys.
+
+.. code:: ipython2
+
+    J('0 [[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]]   [pop] [first +] [step] treegrind')
+
+
+.. parsed-literal::
+
+    44
+
+
+Rebuild the tree using ``map`` (imitating ``treestep``.)
+
+.. code:: ipython2
+
+    J('[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]]   [] [[100 +] infra] [map cons] treegrind')
+
+
+.. parsed-literal::
+
+    [[103 0] [[102 0] [] []] [[109 0] [[105 0] [[104 0] [] []] [[108 0] [[106 0] [] [[107 0] [] []]] []]] []]]
+
+
+Do we have the flexibility to reimplement ``Tree-get``?
+-------------------------------------------------------
+
+I think we do:
+
+::
+
+    [B] [N] [C] treegrind
+
+We'll start by saying that the base-case (the key is not in the tree) is
+user defined, and the per-node function is just the query key literal:
+
+::
+
+    [B] [query_key] [C] treegrind
+
+This means we just have to define ``C`` from:
+
+::
+
+    [key value] query_key [left right] [K] C
+
+Let's try ``cmp``:
+
+::
+
+    C == P [T>] [E] [T<] cmp
+
+    [key value] query_key [left right] [K] P [T>] [E] [T<] cmp
+
+The predicate ``P``
+~~~~~~~~~~~~~~~~~~~
+
+Seems pretty easy (we must preserve the value in case the keys are
+equal):
+
+::
+
+    [key value] query_key [left right] [K] P
+    [key value] query_key [left right] [K] roll<
+    [key value] [left right] [K] query_key       [roll< uncons swap] dip
+
+    [key value] [left right] [K] roll< uncons swap query_key
+    [left right] [K] [key value]       uncons swap query_key
+    [left right] [K] key [value]              swap query_key
+    [left right] [K] [value] key                   query_key
+
+    P == roll< [roll< uncons swap] dip
+
+(Possibly with a swap at the end? Or just swap ``T<`` and ``T>``.)
+
+So now:
+
+::
+
+    [left right] [K] [value] key query_key [T>] [E] [T<] cmp
+
+Becomes one of these three:
+
+::
+
+    [left right] [K] [value] T>
+    [left right] [K] [value] E
+    [left right] [K] [value] T<
+
+``E``
+~~~~~
+
+Easy.
+
+::
+
+    E == roll> popop first
+
+``T<`` and ``T>``
+~~~~~~~~~~~~~~~~~
+
+::
+
+    T< == pop [first] dip i
+    T> == pop [second] dip i
+
+Putting it together
+-------------------
+
+::
+
+    T> == pop [first] dip i
+    T< == pop [second] dip i
+    E == roll> popop first
+    P == roll< [roll< uncons swap] dip
+
+    Tree-get == [P [T>] [E] [T<] cmp] treegrind
+
+To me, that seems simpler than the ``genrec`` version.
+
+.. code:: ipython2
+
+    DefinitionWrapper.add_definitions('''
+    
+        T> == pop [first] dip i
+        T< == pop [second] dip i
+        E == roll> popop first
+        P == roll< [roll< uncons swap] dip
+    
+        Tree-get == [P [T>] [E] [T<] cmp] treegrind
+    
+    ''', D)
+
+.. code:: ipython2
+
+    J('''\
+    
+    [[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]
+    
+    [] [5] Tree-get
+    
+    ''')
+
+
+.. parsed-literal::
+
+    15
+
+
+.. code:: ipython2
+
+    J('''\
+    
+    [[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]
+    
+    [pop "nope"] [25] Tree-get
+    
+    ''')
+
+
+.. parsed-literal::
+
+    'nope'
+
diff --git a/docs/sphinx_docs/notebooks/index.rst b/docs/sphinx_docs/notebooks/index.rst
index 660fd8c..00fa66a 100644
--- a/docs/sphinx_docs/notebooks/index.rst
+++ b/docs/sphinx_docs/notebooks/index.rst
@@ -10,7 +10,8 @@ These essays are adapted from Jupyter notebooks.  I hope to have those hosted so
 
    Developing
    Replacing
-   Trees
+   Ordered_Binary_Trees
+   Treestep
    Newton-Raphson
    Quadratic
    NoUpdates
diff --git a/setup.py b/setup.py
index 3a64666..9b9d4d7 100755
--- a/setup.py
+++ b/setup.py
@@ -24,7 +24,7 @@ from textwrap import dedent
 
 setup(
   name='Thun',
-  version='0.1.1',
+  version='0.2.0',
   description='Python Implementation of Joy',
   long_description=dedent('''\
     Joy is a programming language created by Manfred von Thun that is easy to