1614 lines
241 KiB
HTML
1614 lines
241 KiB
HTML
|
||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||
|
||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
<head>
|
||
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
|
||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||
<title>Treating Trees — 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>
|
||
<script type="text/javascript" src="../_static/jquery.js"></script>
|
||
<script type="text/javascript" src="../_static/underscore.js"></script>
|
||
<script type="text/javascript" src="../_static/doctools.js"></script>
|
||
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="next" title="Newton’s method" href="Newton-Raphson.html" />
|
||
<link rel="prev" title="Replacing Functions in the Dictionary" href="Replacing.html" />
|
||
|
||
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
|
||
|
||
|
||
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
|
||
|
||
</head><body>
|
||
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<div class="section" id="treating-trees">
|
||
<h1>Treating Trees<a class="headerlink" href="#treating-trees" title="Permalink to this headline">¶</a></h1>
|
||
<p>Although any expression in Joy can be considered to describe a
|
||
<a class="reference external" href="https://en.wikipedia.org/wiki/Tree_structure">tree</a> with the quotes
|
||
as compound nodes and the non-quote values as leaf nodes, in this page I
|
||
want to talk about <a class="reference external" href="https://en.wikipedia.org/wiki/Binary_search_tree">ordered binary
|
||
trees</a> and how to
|
||
make and use them.</p>
|
||
<p>The basic structure, in a <a class="reference external" href="https://en.wikipedia.org/wiki/Algebraic_data_type">crude type
|
||
notation</a>, is:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span> <span class="p">::</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">BTree</span> <span class="n">BTree</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>That says that a BTree is either the empty quote <code class="docutils literal notranslate"><span class="pre">[]</span></code> or a quote with
|
||
four items: a key, a value, and two BTrees representing the left and
|
||
right branches of the tree.</p>
|
||
<div class="section" id="a-function-to-traverse-a-btree">
|
||
<h2>A Function to Traverse a BTree<a class="headerlink" href="#a-function-to-traverse-a-btree" title="Permalink to this headline">¶</a></h2>
|
||
<p>Let’s take a crack at writing a function that can recursively iterate or
|
||
traverse these trees.</p>
|
||
<div class="section" id="base-case">
|
||
<h3>Base case <code class="docutils literal notranslate"><span class="pre">[]</span></code><a class="headerlink" href="#base-case" title="Permalink to this headline">¶</a></h3>
|
||
<p>The stopping predicate just has to detect the empty list:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</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">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>And since there’s nothing at this node, we just <code class="docutils literal notranslate"><span class="pre">pop</span></code> it:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="node-case-key-value-left-right">
|
||
<h3>Node case <code class="docutils literal notranslate"><span class="pre">[key</span> <span class="pre">value</span> <span class="pre">left</span> <span class="pre">right]</span></code><a class="headerlink" href="#node-case-key-value-left-right" title="Permalink to this headline">¶</a></h3>
|
||
<p>Now we need to figure out <code class="docutils literal notranslate"><span class="pre">R0</span></code> and <code class="docutils literal notranslate"><span class="pre">R1</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span><span class="p">]</span> <span class="n">ifte</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Let’s look at it <em>in situ</em>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="processing-the-current-node">
|
||
<h3>Processing the current node.<a class="headerlink" href="#processing-the-current-node" title="Permalink to this headline">¶</a></h3>
|
||
<p><code class="docutils literal notranslate"><span class="pre">R0</span></code> is almost certainly going to use <code class="docutils literal notranslate"><span class="pre">dup</span></code> to make a copy of the
|
||
node and then <code class="docutils literal notranslate"><span class="pre">dip</span></code> on some function to process the copy with it:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">F</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>For example, if we’re getting all the keys <code class="docutils literal notranslate"><span class="pre">F</span></code> would be <code class="docutils literal notranslate"><span class="pre">first</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R0</span> <span class="o">==</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dupdip</span>
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dupdip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">first</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="recur">
|
||
<h3>Recur<a class="headerlink" href="#recur" title="Permalink to this headline">¶</a></h3>
|
||
<p>Now <code class="docutils literal notranslate"><span class="pre">R1</span></code> needs to apply <code class="docutils literal notranslate"><span class="pre">[BTree-iter]</span></code> to <code class="docutils literal notranslate"><span class="pre">left</span></code> and <code class="docutils literal notranslate"><span class="pre">right</span></code>. If
|
||
we drop the key and value from the node using <code class="docutils literal notranslate"><span class="pre">rest</span></code> twice we are left
|
||
with an interesting situation:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="p">[</span><span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">rest</span> <span class="n">rest</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Hmm, will <code class="docutils literal notranslate"><span class="pre">step</span></code> do?</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">step</span>
|
||
<span class="n">key</span> <span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="p">[</span><span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">step</span>
|
||
<span class="n">key</span> <span class="n">left</span><span class="o">-</span><span class="n">keys</span> <span class="p">[</span><span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">step</span>
|
||
<span class="n">key</span> <span class="n">left</span><span class="o">-</span><span class="n">keys</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span>
|
||
<span class="n">key</span> <span class="n">left</span><span class="o">-</span><span class="n">keys</span> <span class="n">right</span><span class="o">-</span><span class="n">keys</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R1</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">dip</span> <span class="n">step</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="putting-it-together">
|
||
<h3>Putting it together<a class="headerlink" href="#putting-it-together" title="Permalink to this headline">¶</a></h3>
|
||
<p>We have:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="p">[[</span><span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">dip</span> <span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>When I was reading this over I realized <code class="docutils literal notranslate"><span class="pre">rest</span> <span class="pre">rest</span></code> could go in
|
||
<code class="docutils literal notranslate"><span class="pre">R0</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>(And <code class="docutils literal notranslate"><span class="pre">[step]</span> <span class="pre">genrec</span></code> is such a cool and suggestive combinator!)</p>
|
||
</div>
|
||
<div class="section" id="parameterizing-the-f-per-node-processing-function">
|
||
<h3>Parameterizing the <code class="docutils literal notranslate"><span class="pre">F</span></code> per-node processing function.<a class="headerlink" href="#parameterizing-the-f-per-node-processing-function" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Working backward:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span> <span class="p">[</span><span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Ergo:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span> <span class="p">[</span><span class="n">dupdip</span> <span class="n">rest</span> <span class="n">rest</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">step</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span><span class="p">,</span> <span class="n">define</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'BTree-iter == [not] [pop] roll< [dupdip rest rest] cons [step] genrec'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] [23] BTree-iter'</span><span class="p">)</span> <span class="c1"># It doesn't matter what F is as it won't be used.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">nothing</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["tommy" 23 [] []] [first] BTree-iter'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'tommy'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["tommy" 23 ["richard" 48 [] []] ["jenny" 18 [] []]] [first] BTree-iter'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'tommy'</span> <span class="s1">'richard'</span> <span class="s1">'jenny'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["tommy" 23 ["richard" 48 [] []] ["jenny" 18 [] []]] [second] BTree-iter'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span> <span class="mi">48</span> <span class="mi">18</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="adding-nodes-to-the-btree">
|
||
<h2>Adding Nodes to the BTree<a class="headerlink" href="#adding-nodes-to-the-btree" title="Permalink to this headline">¶</a></h2>
|
||
<p>Let’s consider adding nodes to a BTree structure.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span> <span class="n">value</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="o">==</span> <span class="n">BTree</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="section" id="adding-to-an-empty-node">
|
||
<h3>Adding to an empty node.<a class="headerlink" href="#adding-to-an-empty-node" title="Permalink to this headline">¶</a></h3>
|
||
<p>If the current node is <code class="docutils literal notranslate"><span class="pre">[]</span></code> then you just return
|
||
<code class="docutils literal notranslate"><span class="pre">[key</span> <span class="pre">value</span> <span class="pre">[]</span> <span class="pre">[]]</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="o">==</span> <span class="p">[</span><span class="n">popop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[[</span><span class="n">pop</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Where <code class="docutils literal notranslate"><span class="pre">BTree-new</span></code> is:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">value</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
|
||
<span class="n">value</span> <span class="n">key</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">value</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'BTree-new == swap [[] []] cons cons'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'"v" "k" BTree-new'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span>
|
||
<span class="s1">'v'</span> <span class="o">.</span> <span class="s1">'k'</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span>
|
||
<span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span>
|
||
<span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="s1">'v'</span> <span class="o">.</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="p">[</span><span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="o">.</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>(As an implementation detail, the <code class="docutils literal notranslate"><span class="pre">[[]</span> <span class="pre">[]]</span></code> literal used in the
|
||
definition of <code class="docutils literal notranslate"><span class="pre">BTree-new</span></code> will be reused to supply the <em>constant</em> tail
|
||
for <em>all</em> new nodes produced by it. This is one of those cases where you
|
||
get amortized storage “for free” by using <a class="reference external" href="https://en.wikipedia.org/wiki/Persistent_data_structure">persistent
|
||
datastructures</a>.
|
||
Because the tail, which is <code class="docutils literal notranslate"><span class="pre">((),</span> <span class="pre">((),</span> <span class="pre">()))</span></code> in Python, is immutable
|
||
and embedded in the definition body for <code class="docutils literal notranslate"><span class="pre">BTree-new</span></code>, all new nodes can
|
||
reuse it as their own tail without fear that some other code somewhere
|
||
will change it.)</p>
|
||
</div>
|
||
<div class="section" id="if-the-current-node-isn-t-empty">
|
||
<h3>If the current node isn’t empty.<a class="headerlink" href="#if-the-current-node-isn-t-empty" title="Permalink to this headline">¶</a></h3>
|
||
<p>We now have to derive <code class="docutils literal notranslate"><span class="pre">R0</span></code> and <code class="docutils literal notranslate"><span class="pre">R1</span></code>, consider:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>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 <code class="docutils literal notranslate"><span class="pre">BTree-add</span></code>, so <code class="docutils literal notranslate"><span class="pre">R0</span></code> is pretty much out of the
|
||
picture.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="o">==</span> <span class="p">[]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="a-predicate-to-compare-keys">
|
||
<h3>A predicate to compare keys.<a class="headerlink" href="#a-predicate-to-compare-keys" title="Permalink to this headline">¶</a></h3>
|
||
<p>The first thing we need to do is compare the the key we’re adding to see
|
||
if it is greater than the node key and <code class="docutils literal notranslate"><span class="pre">branch</span></code> accordingly, although
|
||
in this case it’s easier to write a destructive predicate and then use
|
||
<code class="docutils literal notranslate"><span class="pre">ifte</span></code> to apply it <code class="docutils literal notranslate"><span class="pre">nullary</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="p">[</span><span class="n">P</span> <span class="o">></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">ifte</span>
|
||
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="n">key</span> <span class="n">key_n</span> <span class="o">></span>
|
||
<span class="n">Boolean</span>
|
||
|
||
<span class="n">P</span> <span class="o">></span> <span class="o">==</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="n">P</span> <span class="o"><</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o"><</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'P == pop roll> pop first'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'["k" "v" [] []] "vv" "kk" [0] P >'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">P</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="s1">'kk'</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="n">pop</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="s1">'kk'</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="o">.</span> <span class="n">first</span> <span class="o">></span>
|
||
<span class="s1">'kk'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="o">></span>
|
||
<span class="kc">True</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="if-the-key-we-re-adding-is-greater-than-the-node-s-key">
|
||
<h3>If the key we’re adding is greater than the node’s key.<a class="headerlink" href="#if-the-key-we-re-adding-is-greater-than-the-node-s-key" title="Permalink to this headline">¶</a></h3>
|
||
<p>Here the parantheses are meant to signify that the right-hand side (RHS)
|
||
is not literal, the code in the parentheses is meant to have been
|
||
evaluated:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">T</span> <span class="o">==</span> <span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="p">(</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span><span class="p">)]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="use-infra-on-k">
|
||
<h3>Use <code class="docutils literal notranslate"><span class="pre">infra</span></code> on <code class="docutils literal notranslate"><span class="pre">K</span></code>.<a class="headerlink" href="#use-infra-on-k" title="Permalink to this headline">¶</a></h3>
|
||
<p>So how do we do this? We know we’re going to want to use <code class="docutils literal notranslate"><span class="pre">infra</span></code> on
|
||
some function <code class="docutils literal notranslate"><span class="pre">K</span></code> that has the key and value to work with, as well as
|
||
the quoted copy of <code class="docutils literal notranslate"><span class="pre">BTree-add</span></code> to apply somehow:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">right</span> <span class="n">left</span> <span class="n">value_n</span> <span class="n">key_n</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="o">...</span>
|
||
<span class="n">right</span> <span class="n">value</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="n">left</span> <span class="n">value_n</span> <span class="n">key_n</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Pretty easy:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">right</span> <span class="n">left</span> <span class="n">value_n</span> <span class="n">key_n</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span>
|
||
<span class="n">right</span> <span class="n">left</span> <span class="n">value_n</span> <span class="n">key_n</span> <span class="p">[</span><span class="n">value</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">dipdd</span>
|
||
<span class="n">right</span> <span class="n">value</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="n">left</span> <span class="n">value_n</span> <span class="n">key_n</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">K</span> <span class="o">==</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>And:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="derive-t">
|
||
<h3>Derive <code class="docutils literal notranslate"><span class="pre">T</span></code>.<a class="headerlink" href="#derive-t" title="Permalink to this headline">¶</a></h3>
|
||
<p>So now we’re at getting from this to this:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">T</span>
|
||
<span class="o">...</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>And so <code class="docutils literal notranslate"><span class="pre">T</span></code> is just:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">T</span> <span class="o">==</span> <span class="p">[</span><span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="n">infra</span>
|
||
<span class="n">T</span> <span class="o">==</span> <span class="p">[</span> <span class="n">K</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'K == cons cons dipdd'</span><span class="p">)</span>
|
||
<span class="n">define</span><span class="p">(</span><span class="s1">'T == [K] cons cons cons infra'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'"r" "l" "v" "k" "vv" "kk" [0] K'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="o">.</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="o">.</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="o">.</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">K</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">dipdd</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">dipdd</span>
|
||
<span class="s1">'r'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="o">.</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="o">.</span> <span class="s1">'v'</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="o">.</span> <span class="s1">'k'</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'["k" "v" "l" "r"] "vv" "kk" [0] T'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">T</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">T</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">T</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">T</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">T</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">K</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">K</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">dipdd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="o">.</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="o">.</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="o">.</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="o">.</span> <span class="n">swaack</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="mi">0</span> <span class="s1">'kk'</span> <span class="s1">'vv'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="if-the-key-we-re-adding-is-less-than-the-node-s-key">
|
||
<h3>If the key we’re adding is less than the node’s key.<a class="headerlink" href="#if-the-key-we-re-adding-is-less-than-the-node-s-key" title="Permalink to this headline">¶</a></h3>
|
||
<p>This is very very similar to the above:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">E</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="p">[</span><span class="n">P</span> <span class="o"><</span><span class="p">]</span> <span class="p">[</span><span class="n">Te</span><span class="p">]</span> <span class="p">[</span><span class="n">Ee</span><span class="p">]</span> <span class="n">ifte</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>In this case <code class="docutils literal notranslate"><span class="pre">Te</span></code> works that same as <code class="docutils literal notranslate"><span class="pre">T</span></code> but on the left child tree
|
||
instead of the right, so the only difference is that it must use
|
||
<code class="docutils literal notranslate"><span class="pre">dipd</span></code> instead of <code class="docutils literal notranslate"><span class="pre">dipdd</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Te</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>This suggests an alternate factorization:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ccons</span> <span class="o">==</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">T</span> <span class="o">==</span> <span class="p">[</span><span class="n">ccons</span> <span class="n">dipdd</span><span class="p">]</span> <span class="n">ccons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">Te</span> <span class="o">==</span> <span class="p">[</span><span class="n">ccons</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">ccons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>But whatever.</p>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'Te == [cons cons dipd] cons cons cons infra'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'["k" "v" "l" "r"] "vv" "kk" [0] Te'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Te</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Te</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Te</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Te</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">Te</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">dipd</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="o">.</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="o">.</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="o">.</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="p">[]</span> <span class="n">swaack</span>
|
||
<span class="s1">'r'</span> <span class="s1">'l'</span> <span class="s1">'vv'</span> <span class="s1">'kk'</span> <span class="mi">0</span> <span class="s1">'v'</span> <span class="s1">'k'</span> <span class="p">[]</span> <span class="o">.</span> <span class="n">swaack</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="mi">0</span> <span class="s1">'kk'</span> <span class="s1">'vv'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="else-the-keys-must-be-equal">
|
||
<h3>Else the keys must be equal.<a class="headerlink" href="#else-the-keys-must-be-equal" title="Permalink to this headline">¶</a></h3>
|
||
<p>This means we must find:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">Ee</span>
|
||
<span class="o">...</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>This is another easy one:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Ee</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="n">value</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="p">[</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'Ee == pop swap roll< rest rest cons cons'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'["k" "v" "l" "r"] "vv" "k" [0] Ee'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Ee</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Ee</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="s1">'k'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Ee</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="n">Ee</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">Ee</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">.</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'vv'</span> <span class="s1">'k'</span> <span class="o">.</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="o">.</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'k'</span> <span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'v'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="p">[</span><span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="s1">'k'</span> <span class="p">[</span><span class="s1">'vv'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="s1">'k'</span> <span class="s1">'vv'</span> <span class="s1">'l'</span> <span class="s1">'r'</span><span class="p">]</span> <span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'E == [P <] [Te] [Ee] ifte'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="now-we-can-define-btree-add">
|
||
<h3>Now we can define <code class="docutils literal notranslate"><span class="pre">BTree-add</span></code><a class="headerlink" href="#now-we-can-define-btree-add" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="o">==</span> <span class="p">[</span><span class="n">popop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[[</span><span class="n">pop</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="n">P</span> <span class="o">></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">ifte</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Putting it all together:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">roll</span><span class="o">></span> <span class="n">pop</span> <span class="n">first</span>
|
||
<span class="n">T</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">Te</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">Ee</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">E</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="o"><</span><span class="p">]</span> <span class="p">[</span><span class="n">Te</span><span class="p">]</span> <span class="p">[</span><span class="n">Ee</span><span class="p">]</span> <span class="n">ifte</span>
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="o">==</span> <span class="p">[</span><span class="n">popop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[[</span><span class="n">pop</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="n">P</span> <span class="o">></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">ifte</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'BTree-add == [popop not] [[pop] dipd BTree-new] [] [[P >] [T] [E] ifte] genrec'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] 23 "b" BTree-add'</span><span class="p">)</span> <span class="c1"># Initial</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "c" BTree-add'</span><span class="p">)</span> <span class="c1"># Less than</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'c'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "a" BTree-add'</span><span class="p">)</span> <span class="c1"># Greater than</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[</span><span class="s1">'a'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "b" BTree-add'</span><span class="p">)</span> <span class="c1"># Equal to</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] 23 "a" BTree-add 88 "b" BTree-add 44 "c" BTree-add'</span><span class="p">)</span> <span class="c1"># Series.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'a'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'b'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'c'</span> <span class="mi">44</span> <span class="p">[]</span> <span class="p">[]]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="a-set-like-datastructure">
|
||
<h3>A Set-Like Datastructure<a class="headerlink" href="#a-set-like-datastructure" title="Permalink to this headline">¶</a></h3>
|
||
<p>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
|
||
<cite>:math:`O(log_2 N)</cite> <<a class="reference external" href="https://en.wikipedia.org/wiki/Binary_search_tree#cite_note-2">https://en.wikipedia.org/wiki/Binary_search_tree#cite_note-2</a>>`__
|
||
time.</p>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] [3 9 5 2 8 6 7 8 4] [0 swap BTree-add] step'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[</span><span class="mi">9</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">5</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[</span><span class="mi">8</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">6</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[</span><span class="mi">7</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]]</span> <span class="p">[]]]</span> <span class="p">[]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'to_set == [] swap [0 swap BTree-add] step'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[3 9 5 2 8 6 7 8 4] to_set'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[</span><span class="mi">9</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">5</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[</span><span class="mi">8</span> <span class="mi">0</span> <span class="p">[</span><span class="mi">6</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[</span><span class="mi">7</span> <span class="mi">0</span> <span class="p">[]</span> <span class="p">[]]]</span> <span class="p">[]]]</span> <span class="p">[]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>And with that we can write a little program to remove duplicate items
|
||
from a list.</p>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'unique == [to_set [first] BTree-iter] cons run'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[3 9 3 5 2 9 8 8 8 6 2 7 8 4 3] unique'</span><span class="p">)</span> <span class="c1"># Filter duplicate items.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">7</span> <span class="mi">6</span> <span class="mi">8</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">9</span> <span class="mi">2</span> <span class="mi">3</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="interlude-the-cmp-combinator">
|
||
<h2>Interlude: The <code class="docutils literal notranslate"><span class="pre">cmp</span></code> combinator<a class="headerlink" href="#interlude-the-cmp-combinator" title="Permalink to this headline">¶</a></h2>
|
||
<p>Instead of all this mucking about with nested <code class="docutils literal notranslate"><span class="pre">ifte</span></code> let’s just go
|
||
whole hog and define <code class="docutils literal notranslate"><span class="pre">cmp</span></code> 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:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">></span> <span class="n">b</span>
|
||
<span class="n">G</span>
|
||
|
||
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
|
||
<span class="n">E</span>
|
||
|
||
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o"><</span> <span class="n">b</span>
|
||
<span class="n">L</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We need a new non-destructive predicate <code class="docutils literal notranslate"><span class="pre">P</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">P</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">over</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">key</span> <span class="n">Q</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">key</span> <span class="n">popop</span> <span class="n">popop</span> <span class="n">first</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="n">popop</span> <span class="n">first</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">first</span>
|
||
<span class="n">key_n</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">key</span> <span class="n">key_n</span>
|
||
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">over</span> <span class="p">[</span><span class="n">popop</span> <span class="n">popop</span> <span class="n">first</span><span class="p">]</span> <span class="n">nullary</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Here are the definitions again, pruned and renamed in some cases:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">over</span> <span class="p">[</span><span class="n">popop</span> <span class="n">popop</span> <span class="n">first</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipdd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">cons</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">E</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Using <code class="docutils literal notranslate"><span class="pre">cmp</span></code> to simplify <cite>our code above at
|
||
``R1`</cite> <#If-the-current-node-isn’t-empty.>`__:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The line above becomes one of the three lines below:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">T</span><span class="o">></span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">E</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">value</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span><span class="p">]</span> <span class="n">T</span><span class="o"><</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The definition is a little longer but, I think, more elegant and easier
|
||
to understand:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">add</span> <span class="o">==</span> <span class="p">[</span><span class="n">popop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[[</span><span class="n">pop</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">BTree</span><span class="o">-</span><span class="n">new</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[</span><span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="k">import</span> <span class="n">FunctionWrapper</span>
|
||
<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="k">import</span> <span class="n">pushback</span>
|
||
<span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">D</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="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">></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"><</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">'cmp'</span><span class="p">]</span> <span class="o">=</span> <span class="n">cmp_</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s2">"1 0 ['G'] ['E'] ['L'] cmp"</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'G'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s2">"1 1 ['G'] ['E'] ['L'] cmp"</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'E'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s2">"0 1 ['G'] ['E'] ['L'] cmp"</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'L'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="k">import</span> <span class="n">DefinitionWrapper</span>
|
||
|
||
|
||
<span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="s1">'''</span>
|
||
|
||
<span class="s1">P == over [popop popop first] nullary</span>
|
||
<span class="s1">T> == [cons cons dipdd] cons cons cons infra</span>
|
||
<span class="s1">T< == [cons cons dipd] cons cons cons infra</span>
|
||
<span class="s1">E == pop swap roll< rest rest cons cons</span>
|
||
|
||
<span class="s1">BTree-add == [popop not] [[pop] dipd BTree-new] [] [P [T>] [E] [T<] cmp] genrec</span>
|
||
|
||
<span class="s1">'''</span><span class="p">,</span> <span class="n">D</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] 23 "b" BTree-add'</span><span class="p">)</span> <span class="c1"># Initial</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "c" BTree-add'</span><span class="p">)</span> <span class="c1"># Less than</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'c'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "a" BTree-add'</span><span class="p">)</span> <span class="c1"># Greater than</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">23</span> <span class="p">[</span><span class="s1">'a'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["b" 23 [] []] 88 "b" BTree-add'</span><span class="p">)</span> <span class="c1"># Equal to</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'b'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] 23 "a" BTree-add 88 "b" BTree-add 44 "c" BTree-add'</span><span class="p">)</span> <span class="c1"># Series.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'a'</span> <span class="mi">23</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'b'</span> <span class="mi">88</span> <span class="p">[]</span> <span class="p">[</span><span class="s1">'c'</span> <span class="mi">44</span> <span class="p">[]</span> <span class="p">[]]]]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="interlude-factoring-and-naming">
|
||
<h2>Interlude: Factoring and Naming<a class="headerlink" href="#interlude-factoring-and-naming" title="Permalink to this headline">¶</a></h2>
|
||
<p>It may seem silly, but a big part of programming in Forth (and therefore
|
||
in Joy) is the idea of small, highly-factored definitions. If you choose
|
||
names carefully the resulting definitions can take on a semantic role.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span> <span class="o">==</span> <span class="n">popop</span> <span class="n">popop</span> <span class="n">first</span>
|
||
<span class="n">remove</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span><span class="o">-</span><span class="n">from</span><span class="o">-</span><span class="n">node</span> <span class="o">==</span> <span class="n">rest</span> <span class="n">rest</span>
|
||
<span class="n">pack</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span> <span class="o">==</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
<span class="n">prep</span><span class="o">-</span><span class="n">new</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span>
|
||
<span class="n">pack</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">apply</span> <span class="o">==</span> <span class="p">[</span><span class="n">pack</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">cons</span> <span class="n">pack</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span> <span class="n">infra</span>
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">pack</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">over</span> <span class="p">[</span><span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="p">[</span><span class="n">dipdd</span><span class="p">]</span> <span class="n">pack</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">apply</span>
|
||
<span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="p">[</span><span class="n">dipd</span><span class="p">]</span> <span class="n">pack</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">apply</span>
|
||
<span class="n">E</span> <span class="o">==</span> <span class="n">prep</span><span class="o">-</span><span class="n">new</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span> <span class="n">remove</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span><span class="o">-</span><span class="n">from</span><span class="o">-</span><span class="n">node</span> <span class="n">pack</span><span class="o">-</span><span class="n">key</span><span class="o">-</span><span class="ow">and</span><span class="o">-</span><span class="n">value</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="a-version-of-btree-iter-that-does-in-order-traversal">
|
||
<h2>A Version of <code class="docutils literal notranslate"><span class="pre">BTree-iter</span></code> that does In-Order Traversal<a class="headerlink" href="#a-version-of-btree-iter-that-does-in-order-traversal" title="Permalink to this headline">¶</a></h2>
|
||
<p>If you look back to the <cite>non-empty case of the ``BTree-iter`</cite>
|
||
function <#Node-case-%5Bkey-value-left-right%5D>`__ we can design a
|
||
varient 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.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span><span class="p">]</span> <span class="n">ifte</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>To define <code class="docutils literal notranslate"><span class="pre">R0</span></code> and <code class="docutils literal notranslate"><span class="pre">R1</span></code> it helps to look at them as they will appear
|
||
when they run:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="section" id="process-the-left-child">
|
||
<h3>Process the left child.<a class="headerlink" href="#process-the-left-child" title="Permalink to this headline">¶</a></h3>
|
||
<p>Staring at this for a bit suggests <code class="docutils literal notranslate"><span class="pre">dup</span> <span class="pre">third</span></code> to start:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">dup</span> <span class="n">third</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now maybe:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">cons</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="process-the-current-node">
|
||
<h3>Process the current node.<a class="headerlink" href="#process-the-current-node" title="Permalink to this headline">¶</a></h3>
|
||
<p>So far, so good. Now we need to process the current node’s values:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">F</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If <code class="docutils literal notranslate"><span class="pre">F</span></code> needs items from the stack below the left stuff it should have
|
||
<code class="docutils literal notranslate"><span class="pre">cons</span></code>’d them before beginning maybe? For functions like <code class="docutils literal notranslate"><span class="pre">first</span></code> it
|
||
works fine as-is.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">first</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="process-the-right-child">
|
||
<h3>Process the right child.<a class="headerlink" href="#process-the-right-child" title="Permalink to this headline">¶</a></h3>
|
||
<p>First ditch the rest of the node and get the right child:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[</span><span class="n">rest</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">first</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Then, of course, we just need <code class="docutils literal notranslate"><span class="pre">i</span></code> to run <code class="docutils literal notranslate"><span class="pre">BTree-iter-order</span></code> on the
|
||
right side:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="defining-btree-iter-order">
|
||
<h3>Defining <code class="docutils literal notranslate"><span class="pre">BTree-iter-order</span></code><a class="headerlink" href="#defining-btree-iter-order" title="Permalink to this headline">¶</a></h3>
|
||
<p>The result is a little awkward:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R1</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">rest</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">first</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Let’s do a little semantic factoring:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fourth</span> <span class="o">==</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">first</span>
|
||
|
||
<span class="n">proc_left</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span>
|
||
<span class="n">proc_current</span> <span class="o">==</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">proc_right</span> <span class="o">==</span> <span class="p">[</span><span class="n">fourth</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">dup</span> <span class="n">third</span><span class="p">]</span> <span class="p">[</span><span class="n">proc_left</span> <span class="n">proc_current</span> <span class="n">proc_right</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now we can sort sequences.</p>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'BTree-iter-order == [not] [pop] [dup third] [[cons dip] dupdip [[first] dupdip] dip [rest rest rest first] dip i] genrec'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[3 9 5 2 8 6 7 8 4] to_set BTree-iter-order'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="getting-values-by-key">
|
||
<h2>Getting values by key<a class="headerlink" href="#getting-values-by-key" title="Permalink to this headline">¶</a></h2>
|
||
<p>Let’s derive a function that accepts a tree and a key and returns the
|
||
value associated with that key.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">tree</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
<span class="o">------------------------</span>
|
||
<span class="n">value</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="section" id="the-base-case">
|
||
<h3>The base case <code class="docutils literal notranslate"><span class="pre">[]</span></code><a class="headerlink" href="#the-base-case" title="Permalink to this headline">¶</a></h3>
|
||
<p>As before, the stopping predicate just has to detect the empty list:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</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">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>But what do we do if the key isn’t in the tree? In Python we might raise
|
||
a <code class="docutils literal notranslate"><span class="pre">KeyError</span></code> 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”, methinks.)</p>
|
||
<p>Let’s pass the buck to the caller by making the base case a given, you
|
||
have to decide for yourself what <code class="docutils literal notranslate"><span class="pre">[E]</span></code> should be.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
<span class="o">----------------------------</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">tree</span>
|
||
<span class="n">value</span>
|
||
|
||
<span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
<span class="o">----------------------------</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">tree</span>
|
||
<span class="n">tree</span> <span class="n">key</span> <span class="n">E</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now we define:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Note that this <code class="docutils literal notranslate"><span class="pre">BTree-get</span></code> creates a slightly different function than
|
||
itself and <em>that function</em> does the actual recursion. This kind of
|
||
higher-level programming is unusual in most languages but natural in
|
||
Joy.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</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">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The anonymous specialized recursive function that will do the real work.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">pop</span> <span class="ow">not</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">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="id1">
|
||
<h3>Node case <code class="docutils literal notranslate"><span class="pre">[key</span> <span class="pre">value</span> <span class="pre">left</span> <span class="pre">right]</span></code><a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
|
||
<p>Now we need to figure out <code class="docutils literal notranslate"><span class="pre">R0</span></code> and <code class="docutils literal notranslate"><span class="pre">R1</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We want to compare the search key with the key in the node, and if they
|
||
are the same return the value and if they differ then recurse on one of
|
||
the child nodes. So it’s very similar to the above funtion, with
|
||
<code class="docutils literal notranslate"><span class="pre">[R0]</span> <span class="pre">==</span> <span class="pre">[]</span></code> and <code class="docutils literal notranslate"><span class="pre">R1</span> <span class="pre">==</span> <span class="pre">P</span> <span class="pre">[T>]</span> <span class="pre">[E]</span> <span class="pre">[T<]</span> <span class="pre">cmp</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">popop</span> <span class="n">first</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">over</span> <span class="p">[</span><span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span><span class="p">]</span> <span class="n">nullary</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The only difference is that <code class="docutils literal notranslate"><span class="pre">get-node-key</span></code> does one less <code class="docutils literal notranslate"><span class="pre">pop</span></code>
|
||
because there’s no value to discard. Now we have to derive the branches:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o">></span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">E</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o"><</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The cases of <code class="docutils literal notranslate"><span class="pre">T></span></code> and <code class="docutils literal notranslate"><span class="pre">T<</span></code> are similar to above but instead of using
|
||
<code class="docutils literal notranslate"><span class="pre">infra</span></code> we have to discard the rest of the structure:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="n">right</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="n">left</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="p">[</span><span class="n">fourth</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">i</span>
|
||
<span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="p">[</span><span class="n">third</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">i</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>E.g.:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="p">[</span><span class="n">fourth</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">i</span>
|
||
<span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">fourth</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">right</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">right</span> <span class="n">key</span> <span class="n">BTree</span><span class="o">-</span><span class="n">get</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>And:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key_n</span> <span class="n">value_n</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="n">get</span><span class="p">]</span> <span class="n">E</span> <span class="o">==</span> <span class="n">value_n</span>
|
||
|
||
<span class="n">E</span> <span class="o">==</span> <span class="n">popop</span> <span class="n">second</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fourth</span> <span class="o">==</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">first</span>
|
||
<span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">popop</span> <span class="n">first</span>
|
||
<span class="n">P</span> <span class="o">==</span> <span class="n">over</span> <span class="p">[</span><span class="n">get</span><span class="o">-</span><span class="n">node</span><span class="o">-</span><span class="n">key</span><span class="p">]</span> <span class="n">nullary</span>
|
||
<span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="p">[</span><span class="n">fourth</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">i</span>
|
||
<span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="p">[</span><span class="n">third</span><span class="p">]</span> <span class="n">dipd</span> <span class="n">i</span>
|
||
<span class="n">E</span> <span class="o">==</span> <span class="n">popop</span> <span class="n">second</span>
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="n">get</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="p">[]</span> <span class="p">[</span><span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># I don't want to deal with name conflicts with the above so I'm inlining everything here.</span>
|
||
<span class="c1"># The original Joy system has "hide" which is a meta-command which allows you to use named</span>
|
||
<span class="c1"># definitions that are only in scope for a given definition. I don't want to implement</span>
|
||
<span class="c1"># that (yet) so...</span>
|
||
|
||
|
||
<span class="n">define</span><span class="p">(</span><span class="s1">'''</span>
|
||
<span class="s1">BTree-get == [pop not] swap [] [</span>
|
||
<span class="s1"> over [pop popop first] nullary</span>
|
||
<span class="s1"> [[rest rest rest first] dipd i]</span>
|
||
<span class="s1"> [popop second]</span>
|
||
<span class="s1"> [[third] dipd i]</span>
|
||
<span class="s1"> cmp</span>
|
||
<span class="s1"> ] genrec</span>
|
||
<span class="s1">'''</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] "gary" [popop "err"] BTree-get'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">'err'</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'["gary" 23 [] []] "gary" [popop "err"] BTree-get'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'''</span>
|
||
|
||
<span class="s1"> [] [[0 'a'] [1 'b'] [2 'c']] [i BTree-add] step</span>
|
||
|
||
<span class="s1"> 'c' [popop 'not found'] BTree-get</span>
|
||
|
||
<span class="s1">'''</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">2</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="todo-btree-delete">
|
||
<h2>TODO: BTree-delete<a class="headerlink" href="#todo-btree-delete" title="Permalink to this headline">¶</a></h2>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">Er</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">delete</span>
|
||
<span class="o">--------------------------------</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">tree</span>
|
||
<span class="n">tree</span>
|
||
|
||
<span class="n">tree</span> <span class="n">key</span> <span class="p">[</span><span class="n">Er</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">delete</span>
|
||
<span class="o">--------------------------------</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">tree</span>
|
||
<span class="n">tree</span> <span class="n">key</span> <span class="n">Er</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">Delete</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">Er</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">delete</span>
|
||
<span class="o">------------------------------------</span>
|
||
<span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">Er</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now we get to figure out the recursive case:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">D</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">Er</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="n">R0</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">key</span> <span class="n">over</span> <span class="n">first</span> <span class="n">swap</span> <span class="n">dup</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">node_key</span> <span class="n">key</span> <span class="n">key</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">node_key</span> <span class="n">key</span> <span class="n">key</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">node_key</span> <span class="n">key</span> <span class="n">key</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">cons</span> <span class="n">roll</span><span class="o">></span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">node_key</span> <span class="n">key</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="n">roll</span><span class="o">></span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="n">node_key</span> <span class="n">key</span> <span class="p">[</span><span class="n">T</span><span class="o">></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">T</span><span class="o"><</span><span class="p">]</span> <span class="nb">cmp</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now this:;</p>
|
||
<blockquote>
|
||
<div>[node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp</div></blockquote>
|
||
<p>Becomes one of these three:;</p>
|
||
<blockquote>
|
||
<div>[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<</div></blockquote>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="n">T</span><span class="o">></span>
|
||
<span class="o">-------------------------------------------------</span>
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">key</span> <span class="n">D</span> <span class="n">right</span><span class="p">]</span>
|
||
|
||
|
||
<span class="n">right</span> <span class="n">left</span> <span class="n">node_value</span> <span class="n">node_key</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="n">dipd</span>
|
||
|
||
<span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="p">[</span><span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">></span> <span class="o">==</span> <span class="p">[</span><span class="n">dipd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">T</span><span class="o"><</span> <span class="o">==</span> <span class="p">[</span><span class="n">dipdd</span><span class="p">]</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">node_key</span> <span class="n">node_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">key</span> <span class="n">D</span><span class="p">]</span> <span class="n">E</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">delete</span><span class="p">(</span><span class="n">node</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
|
||
<span class="sd">'''</span>
|
||
<span class="sd"> Return a tree with the value (and key) removed or raise KeyError if</span>
|
||
<span class="sd"> not found.</span>
|
||
<span class="sd"> '''</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">node</span><span class="p">:</span>
|
||
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">,</span> <span class="n">key</span>
|
||
|
||
<span class="n">node_key</span><span class="p">,</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">lower</span><span class="p">,</span> <span class="p">(</span><span class="n">higher</span><span class="p">,</span> <span class="n">_</span><span class="p">)))</span> <span class="o">=</span> <span class="n">node</span>
|
||
|
||
<span class="k">if</span> <span class="n">key</span> <span class="o"><</span> <span class="n">node_key</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">node_key</span><span class="p">,</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">delete</span><span class="p">(</span><span class="n">lower</span><span class="p">,</span> <span class="n">key</span><span class="p">),</span> <span class="p">(</span><span class="n">higher</span><span class="p">,</span> <span class="p">())))</span>
|
||
|
||
<span class="k">if</span> <span class="n">key</span> <span class="o">></span> <span class="n">node_key</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">node_key</span><span class="p">,</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">lower</span><span class="p">,</span> <span class="p">(</span><span class="n">delete</span><span class="p">(</span><span class="n">higher</span><span class="p">,</span> <span class="n">key</span><span class="p">),</span> <span class="p">())))</span>
|
||
|
||
<span class="c1"># So, key == node_key, delete this node itself.</span>
|
||
|
||
<span class="c1"># If we only have one non-empty child node return it. If both child</span>
|
||
<span class="c1"># nodes are empty return an empty node (one of the children.)</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">lower</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">higher</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">higher</span><span class="p">:</span>
|
||
<span class="k">return</span> <span class="n">lower</span>
|
||
|
||
<span class="c1"># If both child nodes are non-empty, we find the highest node in our</span>
|
||
<span class="c1"># lower sub-tree, take its key and value to replace (delete) our own,</span>
|
||
<span class="c1"># then get rid of it by recursively calling delete() on our lower</span>
|
||
<span class="c1"># sub-node with our new key.</span>
|
||
<span class="c1"># (We could also find the lowest node in our higher sub-tree and take</span>
|
||
<span class="c1"># its key and value and delete it. I only implemented one of these</span>
|
||
<span class="c1"># two symmetrical options. Over a lot of deletions this might make</span>
|
||
<span class="c1"># the tree more unbalanced. Oh well.)</span>
|
||
<span class="n">node</span> <span class="o">=</span> <span class="n">lower</span>
|
||
<span class="k">while</span> <span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">]:</span>
|
||
<span class="n">node</span> <span class="o">=</span> <span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
|
||
<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">node</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
|
||
|
||
<span class="k">return</span> <span class="n">key</span><span class="p">,</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">delete</span><span class="p">(</span><span class="n">lower</span><span class="p">,</span> <span class="n">key</span><span class="p">),</span> <span class="p">(</span><span class="n">higher</span><span class="p">,</span> <span class="p">())))</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="tree-with-node-and-list-of-trees">
|
||
<h2>Tree with node and list of trees.<a class="headerlink" href="#tree-with-node-and-list-of-trees" title="Permalink to this headline">¶</a></h2>
|
||
<p>Once we have add, get, and delete we can see about abstracting
|
||
them.</p>
|
||
<p>Let’s consider a tree structure, similar to one described <a class="reference external" 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 and a sequence of zero or more child
|
||
trees. (The asterisk is meant to indicate the <a class="reference external" href="https://en.wikipedia.org/wiki/Kleene_star">Kleene
|
||
star</a>.)</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="o">=</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[</span><span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="section" id="treestep">
|
||
<h3><code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#treestep" title="Permalink to this headline">¶</a></h3>
|
||
<p>In the spirit of <code class="docutils literal notranslate"><span class="pre">step</span></code> we are going to define a combinator
|
||
<code class="docutils literal notranslate"><span class="pre">treestep</span></code> which expects a tree and three additional items: a
|
||
base-case value <code class="docutils literal notranslate"><span class="pre">z</span></code>, and two quoted programs <code class="docutils literal notranslate"><span class="pre">[C]</span></code> and <code class="docutils literal notranslate"><span class="pre">[N]</span></code>.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="n">z</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">treestep</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If the current tree node is empty then just leave <code class="docutils literal notranslate"><span class="pre">z</span></code> on the stack in
|
||
lieu:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[]</span> <span class="n">z</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">treestep</span>
|
||
<span class="o">---------------------------</span>
|
||
<span class="n">z</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Otherwise, evaluate <code class="docutils literal notranslate"><span class="pre">N</span></code> on the node value, <code class="docutils literal notranslate"><span class="pre">map</span></code> the whole function
|
||
(abbreviated here as <code class="docutils literal notranslate"><span class="pre">k</span></code>) over the child trees recursively, and then
|
||
combine the result with <code class="docutils literal notranslate"><span class="pre">C</span></code>.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]]</span> <span class="n">z</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">treestep</span>
|
||
<span class="o">---------------------------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">K</span> <span class="o">==</span> <span class="n">z</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">treestep</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="derive-the-recursive-form">
|
||
<h3>Derive the recursive form.<a class="headerlink" href="#derive-the-recursive-form" title="Permalink to this headline">¶</a></h3>
|
||
<p>Since this is a recursive function, we can begin to derive it by finding
|
||
the <code class="docutils literal notranslate"><span class="pre">ifte</span></code> stage that <code class="docutils literal notranslate"><span class="pre">genrec</span></code> will produce. The predicate and
|
||
base-case functions are trivial, so we just have to derive <code class="docutils literal notranslate"><span class="pre">J</span></code>.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">J</span><span class="p">]</span> <span class="n">ifte</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The behavior of <code class="docutils literal notranslate"><span class="pre">J</span></code> is to accept a (non-empty) tree node and arrive at
|
||
the desired outcome.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]]</span> <span class="n">J</span>
|
||
<span class="o">------------------------------</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So <code class="docutils literal notranslate"><span class="pre">J</span></code> will have some form like:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span> <span class="o">==</span> <span class="o">..</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="o">..</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="o">..</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="o">..</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Let’s dive in. First, unquote the node and <code class="docutils literal notranslate"><span class="pre">dip</span></code> <code class="docutils literal notranslate"><span class="pre">N</span></code>.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]]</span> <span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Next, <code class="docutils literal notranslate"><span class="pre">map</span></code> <code class="docutils literal notranslate"><span class="pre">K</span></code> over teh child trees and combine with <code class="docutils literal notranslate"><span class="pre">C</span></code>.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">K</span><span class="o">.</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span> <span class="o">==</span> <span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Plug it in and convert to <code class="docutils literal notranslate"><span class="pre">genrec</span></code>:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">ifte</span>
|
||
<span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="extract-the-givens-to-parameterize-the-program">
|
||
<h3>Extract the givens to parameterize the program.<a class="headerlink" href="#extract-the-givens-to-parameterize-the-program" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
|
||
<span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="n">z</span> <span class="n">unit</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="n">unit</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
\ <span class="o">.........</span><span class="n">TS0</span><span class="o">............./</span>
|
||
\<span class="o">/</span>
|
||
<span class="n">z</span> <span class="n">TS0</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">i</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
\ <span class="o">......</span><span class="n">TS1</span><span class="o">........./</span>
|
||
\<span class="o">/</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">TS1</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">TS1</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dip</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">TS1</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dip</span> <span class="n">genrec</span>
|
||
<span class="n">z</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">swap</span> <span class="p">[</span><span class="nb">map</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">TS1</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dip</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The givens are all to the left so we have our definition.</p>
|
||
</div>
|
||
<div class="section" id="define-treestep">
|
||
<h3>Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#define-treestep" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">TS0</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="n">swap</span> <span class="n">unit</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span>
|
||
<span class="n">TS1</span> <span class="o">==</span> <span class="p">[</span><span class="n">dip</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">swoncat</span>
|
||
<span class="n">treestep</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[</span><span class="nb">map</span><span class="p">]</span> <span class="n">swoncat</span> <span class="p">[</span><span class="n">TS1</span> <span class="p">[</span><span class="n">TS0</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dip</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="s1">'''</span>
|
||
|
||
<span class="s1"> TS0 == [not] swap unit [pop] swoncat</span>
|
||
<span class="s1"> TS1 == [dip] cons [i] swoncat</span>
|
||
<span class="s1">treestep == swap [map] swoncat [TS1 [TS0] dip] dip genrec</span>
|
||
|
||
<span class="s1">'''</span><span class="p">,</span> <span class="n">D</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[]</span> <span class="mi">0</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">treestep</span>
|
||
<span class="o">---------------------------</span>
|
||
<span class="mi">0</span>
|
||
|
||
|
||
<span class="p">[</span><span class="n">n</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]]</span> <span class="mi">0</span> <span class="p">[</span><span class="nb">sum</span> <span class="o">+</span><span class="p">]</span> <span class="p">[]</span> <span class="n">treestep</span>
|
||
<span class="o">--------------------------------------------------</span>
|
||
<span class="n">n</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="mi">0</span> <span class="p">[</span><span class="nb">sum</span> <span class="o">+</span><span class="p">]</span> <span class="p">[]</span> <span class="n">treestep</span><span class="p">]</span> <span class="nb">map</span> <span class="nb">sum</span> <span class="o">+</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[] 0 [sum +] [] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">0</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[23 []] 0 [sum +] [] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[23 [[2 []] [3 []]]] 0 [sum +] [] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">28</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="a-slight-modification">
|
||
<h3>A slight modification.<a class="headerlink" href="#a-slight-modification" title="Permalink to this headline">¶</a></h3>
|
||
<p>Let’s simplify the tree datastructure definition slightly by just
|
||
letting the children be the <code class="docutils literal notranslate"><span class="pre">rest</span></code> of the tree:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="o">=</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[</span><span class="n">node</span> <span class="n">tree</span><span class="o">*</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">J</span></code> function changes slightly.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">node</span> <span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="n">J</span>
|
||
<span class="o">------------------------------</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
|
||
|
||
<span class="p">[</span><span class="n">node</span> <span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="n">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
<span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">K</span><span class="o">.</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="n">C</span>
|
||
|
||
<span class="n">J</span> <span class="o">==</span> <span class="n">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
|
||
<span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">z</span><span class="p">]</span> <span class="p">[</span><span class="n">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'TS1 == [dip] cons [uncons] swoncat'</span><span class="p">)</span> <span class="c1"># We only need to redefine one word.</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[23 [2] [3]] 0 [sum +] [] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">28</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[23 [2 [8] [9]] [3] [4 []]] 0 [sum +] [] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">49</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>I think these trees seem a little easier to read.</p>
|
||
</div>
|
||
<div class="section" id="redefining-our-btree-in-terms-of-this-form">
|
||
<h3>Redefining our BTree in terms of this form.<a class="headerlink" href="#redefining-our-btree-in-terms-of-this-form" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span> <span class="o">=</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>What kind of functions can we write for this with our <code class="docutils literal notranslate"><span class="pre">treestep</span></code>? The
|
||
pattern for processing a non-empty node is:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="n">N</span> <span class="p">[</span><span class="n">tree</span><span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Plugging in our BTree structure:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">uncons</span> <span class="n">pop</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="n">pop</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">lkey</span> <span class="n">rkey</span> <span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="n">lkey</span> <span class="n">rkey</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] 23 [i] [uncons pop] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span> <span class="mi">23</span> <span class="mi">23</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Doesn’t work because <code class="docutils literal notranslate"><span class="pre">map</span></code> extracts the <code class="docutils literal notranslate"><span class="pre">first</span></code> item of whatever its
|
||
mapped function produces. We have to return a list, rather than
|
||
depositing our results directly on the stack.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">first</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">flatten</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">flatten</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="p">[[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]</span> <span class="p">]</span> <span class="n">flatten</span> <span class="n">cons</span>
|
||
<span class="n">key</span> <span class="p">[</span> <span class="n">lk</span> <span class="n">rk</span> <span class="p">]</span> <span class="n">cons</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">lk</span> <span class="n">rk</span> <span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">flatten</span> <span class="n">cons</span><span class="p">]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">treestep</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [flatten cons] [first] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">2</span> <span class="mi">9</span> <span class="mi">5</span> <span class="mi">4</span> <span class="mi">8</span> <span class="mi">6</span> <span class="mi">7</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>There we go.</p>
|
||
</div>
|
||
<div class="section" id="in-order-traversal-with-treestep">
|
||
<h3>In-order traversal with <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.<a class="headerlink" href="#in-order-traversal-with-treestep" title="Permalink to this headline">¶</a></h3>
|
||
<p>From here:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="p">[[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]]</span> <span class="n">C</span>
|
||
<span class="n">key</span> <span class="p">[[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]]</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="p">[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span>
|
||
<span class="p">[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]</span> <span class="n">key</span> <span class="n">swons</span> <span class="n">concat</span>
|
||
<span class="p">[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">key</span> <span class="n">rk</span><span class="p">]</span> <span class="n">concat</span>
|
||
<span class="p">[</span><span class="n">lk</span> <span class="n">key</span> <span class="n">rk</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">i</span> <span class="n">roll</span><span class="o"><</span> <span class="n">swons</span> <span class="n">concat</span><span class="p">]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">treestep</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [i roll< swons concat] [uncons pop] treestep'</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="miscellaneous-crap">
|
||
<h2>Miscellaneous Crap<a class="headerlink" href="#miscellaneous-crap" title="Permalink to this headline">¶</a></h2>
|
||
<div class="section" id="toy-with-it">
|
||
<h3>Toy with it.<a class="headerlink" href="#toy-with-it" title="Permalink to this headline">¶</a></h3>
|
||
<p>Let’s reexamine:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="o">...</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span>
|
||
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">disenstacken</span> <span class="n">swap</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="n">swap</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="n">left</span>
|
||
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dipdd</span><span class="p">]</span> <span class="n">dupdip</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R0</span> <span class="o">==</span> <span class="n">disenstacken</span> <span class="n">swap</span>
|
||
<span class="n">R1</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">i</span>
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">R0</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">disenstacken</span> <span class="n">swap</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="p">[</span><span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">i</span>
|
||
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="n">left</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span><span class="p">]</span> <span class="n">i</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span>
|
||
|
||
|
||
<span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="o">-</span><span class="n">order</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">disenstacken</span> <span class="n">swap</span><span class="p">]</span> <span class="p">[[</span><span class="n">cons</span> <span class="n">dipdd</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">i</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="refactor-cons-cons">
|
||
<h3>Refactor <code class="docutils literal notranslate"><span class="pre">cons</span> <span class="pre">cons</span></code><a class="headerlink" href="#refactor-cons-cons" title="Permalink to this headline">¶</a></h3>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">cons2</span> <span class="o">==</span> <span class="n">cons</span> <span class="n">cons</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Refactoring:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="n">new</span> <span class="o">==</span> <span class="n">swap</span> <span class="p">[[]</span> <span class="p">[]]</span> <span class="n">cons2</span>
|
||
<span class="n">T</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons2</span> <span class="n">dipdd</span><span class="p">]</span> <span class="n">cons2</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">Te</span> <span class="o">==</span> <span class="p">[</span><span class="n">cons2</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">cons2</span> <span class="n">cons</span> <span class="n">infra</span>
|
||
<span class="n">Ee</span> <span class="o">==</span> <span class="n">pop</span> <span class="n">swap</span> <span class="n">roll</span><span class="o"><</span> <span class="n">rest</span> <span class="n">rest</span> <span class="n">cons2</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>It’s used a lot because it’s tied to the fact that there are two “data
|
||
items” in each node. This point to a more general factorization that
|
||
would render a combinator that could work for other geometries of trees.</p>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="a-general-form-for-trees">
|
||
<h2>A General Form for Trees<a class="headerlink" href="#a-general-form-for-trees" title="Permalink to this headline">¶</a></h2>
|
||
<p>A general form for tree data with N children per node:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="n">data</span><span class="p">]</span> <span class="p">[</span><span class="n">child0</span><span class="p">]</span> <span class="o">...</span> <span class="p">[</span><span class="n">childN</span><span class="o">-</span><span class="mi">1</span><span class="p">]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Suggests a general form of recursive iterator, but I have to go walk the
|
||
dogs at the mo’.</p>
|
||
<p>For a given structure, you would have a structure of operator functions
|
||
and sort of merge them and run them, possibly in a different order (pre-
|
||
post- in- y’know). The <code class="docutils literal notranslate"><span class="pre">Cn</span></code> functions could all be the same and use
|
||
the <code class="docutils literal notranslate"><span class="pre">step</span></code> trick if the children nodes are all of the right kind. If
|
||
they are heterogeneous then we need a way to get the different <code class="docutils literal notranslate"><span class="pre">Cn</span></code>
|
||
into the structure in the right order. If I understand correctly, the
|
||
“Bananas…” paper shows how to do this automatically from a type
|
||
description. They present, if I have it right, a tiny machine that
|
||
accepts <a class="reference external" href="https://en.wikipedia.org/wiki/Catamorphism#General_case">some sort of algebraic data type description and returns a
|
||
function that can recusre over
|
||
it</a>, I
|
||
think.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">data</span><span class="o">..</span> <span class="p">[</span><span class="n">c0</span><span class="p">]</span> <span class="p">[</span><span class="n">c1</span><span class="p">]</span> <span class="o">...</span> <span class="p">[</span><span class="n">cN</span><span class="p">]]</span> <span class="p">[</span><span class="n">F</span> <span class="n">C0</span> <span class="n">C1</span> <span class="o">...</span> <span class="n">CN</span><span class="p">]</span> <span class="n">infil</span>
|
||
<span class="o">--------------------------------------------------------</span>
|
||
<span class="n">data</span> <span class="n">F</span> <span class="p">[</span><span class="n">c0</span><span class="p">]</span> <span class="n">C0</span> <span class="p">[</span><span class="n">c1</span><span class="p">]</span> <span class="n">C1</span> <span class="o">...</span> <span class="p">[</span><span class="n">cN</span><span class="p">]</span> <span class="n">CN</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="section" id="just-make-f-a-parameter">
|
||
<h3>Just make <code class="docutils literal notranslate"><span class="pre">[F]</span></code> a parameter.<a class="headerlink" href="#just-make-f-a-parameter" title="Permalink to this headline">¶</a></h3>
|
||
<p>We can generalize to a sort of pure form:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span><span class="p">]</span> <span class="n">ifte</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Putting <code class="docutils literal notranslate"><span class="pre">[F]</span></code> to the left as a given:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">unit</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[[</span><span class="n">F</span><span class="p">]]</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
<span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Let’s us define a parameterized form:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="o">==</span> <span class="n">unit</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">roll</span><span class="o"><</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>So in the general case of non-empty nodes:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We just define <code class="docutils literal notranslate"><span class="pre">R1</span></code> to do whatever it has to to process the node. For
|
||
example:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span>
|
||
<span class="o">...</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Pre-, ??-, post-order traversals.</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">uncons</span> <span class="n">uncons</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>For pre- and post-order we can use the <code class="docutils literal notranslate"><span class="pre">step</span></code> trick:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">step</span>
|
||
<span class="o">...</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We worked out one scheme for ?in-order? traversal above, but maybe we
|
||
can do better?</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="p">[</span><span class="n">disenstacken</span><span class="p">]</span> <span class="n">dipd</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">disenstacken</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">R1</span><span class="o">.</span><span class="mi">1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Hmm…</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">tuck</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
|
||
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="p">[</span><span class="n">disenstacken</span> <span class="p">[</span><span class="n">roll</span><span class="o">></span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">dipd</span>
|
||
<span class="p">[</span><span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">disenstacken</span> <span class="p">[</span><span class="n">roll</span><span class="o">></span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">right</span> <span class="p">[</span><span class="n">roll</span><span class="o">></span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
<span class="n">key</span> <span class="n">value</span> <span class="n">left</span> <span class="n">roll</span><span class="o">></span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
<span class="n">left</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span>
|
||
|
||
<span class="n">left</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">tuck</span> <span class="n">foo</span>
|
||
<span class="n">left</span> <span class="n">key</span> <span class="n">value</span> <span class="n">right</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span><span class="p">]</span> <span class="n">foo</span>
|
||
<span class="o">...</span>
|
||
<span class="n">left</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span> <span class="n">key</span> <span class="n">value</span> <span class="n">F</span> <span class="n">right</span> <span class="n">BTree</span><span class="o">-</span><span class="nb">iter</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We could just let <code class="docutils literal notranslate"><span class="pre">[R1]</span></code> be a parameter too, for maximum flexibility.</p>
|
||
</div>
|
||
</div>
|
||
<div class="section" id="automatically-deriving-the-recursion-combinator-for-a-data-type">
|
||
<h2>Automatically deriving the recursion combinator for a data type?<a class="headerlink" href="#automatically-deriving-the-recursion-combinator-for-a-data-type" title="Permalink to this headline">¶</a></h2>
|
||
<p>If I understand it correctly, the “Bananas…” paper talks about a way
|
||
to build the processor function automatically from the description of
|
||
the type. I think if we came up with an elegant way for the Joy code to
|
||
express that, it would be cool. In Joypy the definitions can be circular
|
||
because lookup happens at evaluation, not parsing. E.g.:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">A</span> <span class="o">==</span> <span class="o">...</span> <span class="n">B</span> <span class="o">...</span>
|
||
<span class="n">B</span> <span class="o">==</span> <span class="o">...</span> <span class="n">A</span> <span class="o">...</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>That’s fine. Circular datastructures can’t be made though.</p>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
||
<div class="sphinxsidebarwrapper">
|
||
<h3><a href="../index.html">Table Of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#">Treating Trees</a><ul>
|
||
<li><a class="reference internal" href="#a-function-to-traverse-a-btree">A Function to Traverse a BTree</a><ul>
|
||
<li><a class="reference internal" href="#base-case">Base case <code class="docutils literal notranslate"><span class="pre">[]</span></code></a></li>
|
||
<li><a class="reference internal" href="#node-case-key-value-left-right">Node case <code class="docutils literal notranslate"><span class="pre">[key</span> <span class="pre">value</span> <span class="pre">left</span> <span class="pre">right]</span></code></a></li>
|
||
<li><a class="reference internal" href="#processing-the-current-node">Processing the current node.</a></li>
|
||
<li><a class="reference internal" href="#recur">Recur</a></li>
|
||
<li><a class="reference internal" href="#putting-it-together">Putting it together</a></li>
|
||
<li><a class="reference internal" href="#parameterizing-the-f-per-node-processing-function">Parameterizing the <code class="docutils literal notranslate"><span class="pre">F</span></code> per-node processing function.</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#adding-nodes-to-the-btree">Adding Nodes to the BTree</a><ul>
|
||
<li><a class="reference internal" href="#adding-to-an-empty-node">Adding to an empty node.</a></li>
|
||
<li><a class="reference internal" href="#if-the-current-node-isn-t-empty">If the current node isn’t empty.</a></li>
|
||
<li><a class="reference internal" href="#a-predicate-to-compare-keys">A predicate to compare keys.</a></li>
|
||
<li><a class="reference internal" href="#if-the-key-we-re-adding-is-greater-than-the-node-s-key">If the key we’re adding is greater than the node’s key.</a></li>
|
||
<li><a class="reference internal" href="#use-infra-on-k">Use <code class="docutils literal notranslate"><span class="pre">infra</span></code> on <code class="docutils literal notranslate"><span class="pre">K</span></code>.</a></li>
|
||
<li><a class="reference internal" href="#derive-t">Derive <code class="docutils literal notranslate"><span class="pre">T</span></code>.</a></li>
|
||
<li><a class="reference internal" href="#if-the-key-we-re-adding-is-less-than-the-node-s-key">If the key we’re adding is less than the node’s key.</a></li>
|
||
<li><a class="reference internal" href="#else-the-keys-must-be-equal">Else the keys must be equal.</a></li>
|
||
<li><a class="reference internal" href="#now-we-can-define-btree-add">Now we can define <code class="docutils literal notranslate"><span class="pre">BTree-add</span></code></a></li>
|
||
<li><a class="reference internal" href="#a-set-like-datastructure">A Set-Like Datastructure</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#interlude-the-cmp-combinator">Interlude: The <code class="docutils literal notranslate"><span class="pre">cmp</span></code> combinator</a></li>
|
||
<li><a class="reference internal" href="#interlude-factoring-and-naming">Interlude: Factoring and Naming</a></li>
|
||
<li><a class="reference internal" href="#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><ul>
|
||
<li><a class="reference internal" href="#process-the-left-child">Process the left child.</a></li>
|
||
<li><a class="reference internal" href="#process-the-current-node">Process the current node.</a></li>
|
||
<li><a class="reference internal" href="#process-the-right-child">Process the right child.</a></li>
|
||
<li><a class="reference internal" href="#defining-btree-iter-order">Defining <code class="docutils literal notranslate"><span class="pre">BTree-iter-order</span></code></a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#getting-values-by-key">Getting values by key</a><ul>
|
||
<li><a class="reference internal" href="#the-base-case">The base case <code class="docutils literal notranslate"><span class="pre">[]</span></code></a></li>
|
||
<li><a class="reference internal" href="#id1">Node case <code class="docutils literal notranslate"><span class="pre">[key</span> <span class="pre">value</span> <span class="pre">left</span> <span class="pre">right]</span></code></a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#todo-btree-delete">TODO: BTree-delete</a></li>
|
||
<li><a class="reference internal" href="#tree-with-node-and-list-of-trees">Tree with node and list of trees.</a><ul>
|
||
<li><a class="reference internal" href="#treestep"><code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
|
||
<li><a class="reference internal" href="#derive-the-recursive-form">Derive the recursive form.</a></li>
|
||
<li><a class="reference internal" href="#extract-the-givens-to-parameterize-the-program">Extract the givens to parameterize the program.</a></li>
|
||
<li><a class="reference internal" href="#define-treestep">Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
|
||
<li><a class="reference internal" href="#a-slight-modification">A slight modification.</a></li>
|
||
<li><a class="reference internal" href="#redefining-our-btree-in-terms-of-this-form">Redefining our BTree in terms of this form.</a></li>
|
||
<li><a class="reference internal" href="#in-order-traversal-with-treestep">In-order traversal with <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#miscellaneous-crap">Miscellaneous Crap</a><ul>
|
||
<li><a class="reference internal" href="#toy-with-it">Toy with it.</a></li>
|
||
<li><a class="reference internal" href="#refactor-cons-cons">Refactor <code class="docutils literal notranslate"><span class="pre">cons</span> <span class="pre">cons</span></code></a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#a-general-form-for-trees">A General Form for Trees</a><ul>
|
||
<li><a class="reference internal" href="#just-make-f-a-parameter">Just make <code class="docutils literal notranslate"><span class="pre">[F]</span></code> a parameter.</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#automatically-deriving-the-recursion-combinator-for-a-data-type">Automatically deriving the recursion combinator for a data type?</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
<div class="relations">
|
||
<h3>Related Topics</h3>
|
||
<ul>
|
||
<li><a href="../index.html">Documentation overview</a><ul>
|
||
<li><a href="index.html">Essays about Programming in Joy</a><ul>
|
||
<li>Previous: <a href="Replacing.html" title="previous chapter">Replacing Functions in the Dictionary</a></li>
|
||
<li>Next: <a href="Newton-Raphson.html" title="next chapter">Newton’s method</a></li>
|
||
</ul></li>
|
||
</ul></li>
|
||
</ul>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../_sources/notebooks/Trees.rst.txt"
|
||
rel="nofollow">Show Source</a></li>
|
||
</ul>
|
||
</div>
|
||
<div id="searchbox" style="display: none" role="search">
|
||
<h3>Quick search</h3>
|
||
<div class="searchformwrapper">
|
||
<form class="search" action="../search.html" method="get">
|
||
<input type="text" name="q" />
|
||
<input type="submit" value="Go" />
|
||
<input type="hidden" name="check_keywords" value="yes" />
|
||
<input type="hidden" name="area" value="default" />
|
||
</form>
|
||
</div>
|
||
</div>
|
||
<script type="text/javascript">$('#searchbox').show(0);</script>
|
||
</div>
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="footer" role="contentinfo">
|
||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">
|
||
<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" />
|
||
</a>
|
||
<br />
|
||
<span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Thun Documentation</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://joypy.osdn.io/" property="cc:attributionName" rel="cc:attributionURL">Simon Forman</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct="http://purl.org/dc/terms/" href="https://osdn.net/projects/joypy/" rel="dct:source">https://osdn.net/projects/joypy/</a>.
|
||
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.3.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |