sforman
/
Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Editing Trees; implemented BTree-Delete.

This commit is contained in:
Simon Forman 2018-05-08 08:34:20 -07:00
parent c3a3f5a527
commit aafecdc035
11 changed files with 771 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

589
docs/Trees.ipynb
View File

@ -133,11 +133,11 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 6,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"from notebook_preamble import J, V, define" "from notebook_preamble import D, J, V, define, DefinitionWrapper"
] ]
}, },
{ {
@ -906,7 +906,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 30, "execution_count": 11,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
@ -917,6 +917,22 @@
"\n", "\n",
"@FunctionWrapper\n", "@FunctionWrapper\n",
"def cmp_(stack, expression, dictionary):\n", "def cmp_(stack, expression, dictionary):\n",
" '''\n",
" cmp takes two values and three quoted programs on the stack and runs\n",
" one of the three depending on the results of comparing the two values:\n",
"\n",
" a b [G] [E] [L] cmp\n",
" ------------------------- a > b\n",
" G\n",
"\n",
" a b [G] [E] [L] cmp\n",
" ------------------------- a = b\n",
" E\n",
"\n",
" a b [G] [E] [L] cmp\n",
" ------------------------- a < b\n",
" L\n",
" '''\n",
" L, (E, (G, (b, (a, stack)))) = stack\n", " L, (E, (G, (b, (a, stack)))) = stack\n",
" expression = pushback(G if a > b else L if a < b else E, expression)\n", " expression = pushback(G if a > b else L if a < b else E, expression)\n",
" return stack, expression, dictionary\n", " return stack, expression, dictionary\n",
@ -925,6 +941,55 @@
"D['cmp'] = cmp_" "D['cmp'] = cmp_"
] ]
}, },
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"from joy.library import FunctionWrapper, S_ifte\n",
"\n",
"\n",
"@FunctionWrapper\n",
"def cond(stack, expression, dictionary):\n",
" '''\n",
" like a case statement; works by rewriting into a chain of ifte.\n",
"\n",
" [..[[Bi] Ti]..[D]] -> ...\n",
"\n",
"\n",
" [[[B0] T0] [[B1] T1] [D]] cond\n",
" -----------------------------------------\n",
" [B0] [T0] [[B1] [T1] [D] ifte] ifte\n",
"\n",
" '''\n",
" conditions, stack = stack\n",
" if conditions:\n",
" expression = _cond(conditions, expression)\n",
" try:\n",
" # Attempt to preload the args to first ifte.\n",
" (P, (T, (E, expression))) = expression\n",
" except ValueError:\n",
" # If, for any reason, the argument to cond should happen to contain\n",
" # only the default clause then this optimization will fail.\n",
" pass\n",
" else:\n",
" stack = (E, (T, (P, stack)))\n",
" return stack, expression, dictionary\n",
"\n",
"\n",
"def _cond(conditions, expression):\n",
" (clause, rest) = conditions\n",
" if not rest: # clause is [D]\n",
" return clause\n",
" P, T = clause\n",
" return (P, (T, (_cond(rest, ()), (S_ifte, expression))))\n",
"\n",
"\n",
"\n",
"D['cond'] = cond"
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 31, "execution_count": 31,
@ -1415,17 +1480,16 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"# TODO: BTree-delete\n", "# BTree-delete\n",
"\n", "\n",
"Then, once we have add, get, and delete we can see about abstracting them.\n",
"\n", "\n",
" tree key [E] BTree-delete\n", " tree key [Er] BTree-delete\n",
" ---------------------------- key in tree\n", " -------------------------------- key in tree\n",
" tree\n", " tree\n",
"\n", "\n",
" tree key [E] BTree-delete\n", " tree key [Er] BTree-delete\n",
" ---------------------------- key not in tree\n", " ---------------------- ------ key not in tree\n",
" tree key E" " tree key Er"
] ]
}, },
{ {
@ -1434,26 +1498,16 @@
"source": [ "source": [
"So:\n", "So:\n",
"\n", "\n",
" BTree-delete == [pop not] [] [R0] [R1] genrec\n", " BTree-Delete == [pop not] swap [R0] [R1] genrec\n"
"\n",
"And:\n",
"\n",
" [n_key n_value left right] key R0 [BTree-get] R1\n",
" [n_key n_value left right] key [dup first] dip [BTree-get] R1\n",
" [n_key n_value left right] n_key key [BTree-get] R1\n",
" [n_key n_value left right] n_key key [BTree-get] roll> [T>] [E] [T<] cmp\n",
" [n_key n_value left right] [BTree-get] n_key key [T>] [E] [T<] cmp\n",
"\n",
" BTree-delete == [pop not] swap [[dup first] dip] [roll> [T>] [E] [T<] cmp] genrec"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
" [n_key n_value left right] [BTree-get] T>\n", " [Er] BTree-delete\n",
" [n_key n_value left right] [BTree-get] E\n", " -------------------------------------\n",
" [n_key n_value left right] [BTree-get] T<" " [pop not] [Er] [R0] [R1] genrec"
] ]
}, },
{ {
@ -1466,32 +1520,493 @@
] ]
}, },
{ {
"cell_type": "code", "cell_type": "markdown",
"execution_count": null,
"metadata": {}, "metadata": {},
"outputs": [], "source": [
"source": [] "Now we get to figure out the recursive case:\n",
"\n",
" w/ D == [pop not] [Er] [R0] [R1] genrec\n",
"\n",
" [node_key node_value left right] key R0 [D] R1\n",
" [node_key node_value left right] key over first swap dup [D] R1\n",
" [node_key node_value left right] node_key key key [D] R1\n",
"\n",
"And then:\n",
"\n",
" [node_key node_value left right] node_key key key [D] R1\n",
" [node_key node_value left right] node_key key key [D] cons roll> [T>] [E] [T<] cmp\n",
" [node_key node_value left right] node_key key [key D] roll> [T>] [E] [T<] cmp\n",
" [node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now this:;\n",
"\n",
" [node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp\n",
"\n",
"Becomes one of these three:;\n",
"\n",
" [node_key node_value left right] [key D] T>\n",
" [node_key node_value left right] [key D] E\n",
" [node_key node_value left right] [key D] T<"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Greater than case and less than case\n",
"\n",
" [node_key node_value left right] [key D] T>\n",
" -------------------------------------------------\n",
" [node_key node_value left key D right]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First:\n",
"\n",
" right left node_value node_key [key D] dipd\n",
" right left key D node_value node_key\n",
" right left' node_value node_key"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ergo:\n",
"\n",
" [node_key node_value left right] [key D] [dipd] cons infra"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So:\n",
"\n",
" T> == [dipd] cons infra\n",
" T< == [dipdd] cons infra"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### The else case\n",
"\n",
" [node_key node_value left right] [key D] E\n",
"\n",
"We have to handle three cases, so let's use `cond`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The first two cases are symmetrical, if we only have one non-empty child node return it.\n",
"\n",
" E == [\n",
" [[pop third not] pop fourth]\n",
" [[pop fourth not] pop third]\n",
" [default]\n",
" ] cond"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(If both child nodes are empty return an empty node.)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The initial structure of the default function:\n",
"\n",
" default == [E'] cons infra\n",
"\n",
" [node_key node_value left right] [key D] default\n",
" [node_key node_value left right] [key D] [E'] cons infra\n",
" [node_key node_value left right] [[key D] E'] infra\n",
"\n",
" right left node_value node_key [key D] E'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If both child nodes are non-empty, we find the highest node in our lower sub-tree, take its key and value to replace (delete) our own, then get rid of it by recursively calling delete() on our lower sub-node with our new key.\n",
"\n",
"(We could also find the lowest node in our higher sub-tree and take its key and value and delete it. I only implemented one of these two symmetrical options. Over a lot of deletions this might make the tree more unbalanced. Oh well.)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First things first, we no longer need this node's key and value:\n",
"\n",
" right left node_value node_key [key D] roll> popop E''\n",
" right left [key D] node_value node_key popop E''\n",
" right left [key D] E''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then we have to we find the highest (right-most) node in our lower (left) sub-tree:\n",
"\n",
" right left [key D] E''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ditch the key:\n",
"\n",
" right left [key D] rest E'''\n",
" right left [D] E'''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Find the right-most node:\n",
"\n",
" right left [D] [dup W] dip E''''\n",
" right left dup W [D] E''''\n",
" right left left W [D] E''''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider:\n",
"\n",
" left W"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We know left is not empty:\n",
"\n",
" [L_key L_value L_left L_right] W"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We want to keep extracting the right node as long as it is not empty:\n",
"\n",
" left [P] [B] while W'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The predicate:\n",
"\n",
" [L_key L_value L_left L_right] P\n",
" [L_key L_value L_left L_right] fourth\n",
" L_right\n",
" \n",
"(This has a bug, can run on `[]` so must be guarded:\n",
"\n",
" if_not_empty == [] swap [] ifte\n",
" ?fourth == [fourth] if_not_empty\n",
" W.rightmost == [?fourth] [fourth] while"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The body is also `fourth`:\n",
"\n",
" left [fourth] [fourth] while W'\n",
" rightest W'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We know rightest is not empty:\n",
"\n",
" [R_key R_value R_left R_right] W'\n",
" [R_key R_value R_left R_right] uncons uncons pop\n",
" R_key [R_value R_left R_right] uncons pop\n",
" R_key R_value [R_left R_right] pop\n",
" R_key R_value"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So:\n",
"\n",
" W == [fourth] [fourth] while uncons uncons pop"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And:\n",
"\n",
" right left left W [D] E''''\n",
" right left R_key R_value [D] E''''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Final stretch. We want to end up with something like:\n",
"\n",
" right left [R_key D] i R_value R_key\n",
" right left R_key D R_value R_key\n",
" right left' R_value R_key"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we adjust our definition of `W` to include `over` at the end:\n",
"\n",
" W == [fourth] [fourth] while uncons uncons pop over"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That will give us:\n",
"\n",
" right left R_key R_value R_key [D] E''''\n",
"\n",
" right left R_key R_value R_key [D] cons dipdd E'''''\n",
" right left R_key R_value [R_key D] dipdd E'''''\n",
" right left R_key D R_key R_value E'''''\n",
" right left' R_key R_value E'''''\n",
" right left' R_key R_value swap\n",
" right left' R_value R_key"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So:\n",
"\n",
" E' == roll> popop E''\n",
"\n",
" E'' == rest E'''\n",
"\n",
" E''' == [dup W] dip E''''\n",
"\n",
" E'''' == cons dipdd swap"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Substituting:\n",
"\n",
" W == [fourth] [fourth] while uncons uncons pop over\n",
" E' == roll> popop rest [dup W] dip cons dipdd swap\n",
" E == [\n",
" [[pop third not] pop fourth]\n",
" [[pop fourth not] pop third]\n",
" [[E'] cons infra]\n",
" ] cond"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Minor rearrangement:\n",
"\n",
" W == dup [fourth] [fourth] while uncons uncons pop over\n",
" E' == roll> popop rest [W] dip cons dipdd swap\n",
" E == [\n",
" [[pop third not] pop fourth]\n",
" [[pop fourth not] pop third]\n",
" [[E'] cons infra]\n",
" ] cond"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Refactoring\n",
"\n",
" W.rightmost == [fourth] [fourth] while\n",
" W.unpack == uncons uncons pop\n",
" E.clear_stuff == roll> popop rest\n",
" E.delete == cons dipdd\n",
" W == dup W.rightmost W.unpack over\n",
" E.0 == E.clear_stuff [W] dip E.delete swap\n",
" E == [\n",
" [[pop third not] pop fourth]\n",
" [[pop fourth not] pop third]\n",
" [[E.0] cons infra]\n",
" ] cond\n",
" T> == [dipd] cons infra\n",
" T< == [dipdd] cons infra\n",
" R0 == over first swap dup\n",
" R1 == cons roll> [T>] [E] [T<] cmp\n",
" BTree-Delete == [pop not] swap [R0] [R1] genrec\n",
"\n",
"By the standards of the code I've written so far, this is a *huge* Joy program."
]
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": 20,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [] "source": [
"DefinitionWrapper.add_definitions('''\n",
"first_two == uncons uncons pop\n",
"fourth == rest rest rest first\n",
"?fourth == [] [fourth] [] ifte\n",
"W.rightmost == [?fourth] [fourth] while\n",
"E.clear_stuff == roll> popop rest\n",
"E.delete == cons dipdd\n",
"W == dup W.rightmost first_two over\n",
"E.0 == E.clear_stuff [W] dip E.delete swap\n",
"E == [[[pop third not] pop fourth] [[pop fourth not] pop third] [[E.0] cons infra]] cond\n",
"T> == [dipd] cons infra\n",
"T< == [dipdd] cons infra\n",
"R0 == over first swap dup\n",
"R1 == cons roll> [T>] [E] [T<] cmp\n",
"BTree-Delete == [pop not] swap [R0] [R1] genrec''', D)"
]
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": 23,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [
"source": [] {
"name": "stdout",
"output_type": "stream",
"text": [
"['a' 23 [] ['b' 88 [] []]]\n"
]
}
],
"source": [
"J(\"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'c' ['Er'] BTree-Delete \")"
]
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": 24,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [
"source": [] {
"name": "stdout",
"output_type": "stream",
"text": [
"['a' 23 [] ['c' 44 [] []]]\n"
]
}
],
"source": [
"J(\"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'b' ['Er'] BTree-Delete \")"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['b' 88 [] ['c' 44 [] []]]\n"
]
}
],
"source": [
"J(\"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'a' ['Er'] BTree-Delete \")"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a' 23 [] ['b' 88 [] ['c' 44 [] 'Er' 'der' []]]]\n"
]
}
],
"source": [
"J(\"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'der' ['Er'] BTree-Delete \")"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]]\n"
]
}
],
"source": [
"J(\"['a' 23 [] ['b' 88 [] ['c' 44 [] []]]] 'der' [pop] BTree-Delete \")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One bug, I forgot to put `not` in the first two clauses of the `cond`.\n",
"\n",
"The behavior of the `[Er]` function should maybe be different: either just silently fail, or maybe implement some sort of function that can grab the pending expression up to a sentinel value or something, allowing for a kind of \"except\"-ish control-flow?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then, once we have add, get, and delete we can see about abstracting them.\n"
]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
@ -2161,7 +2676,7 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython2", "pygments_lexer": "ipython2",
"version": "2.7.13" "version": "2.7.12"
} }
}, },
"nbformat": 4, "nbformat": 4,

1
docs/sphinx_docs/_build/html/index.html
View File

@ -132,6 +132,7 @@ interesting aspects. It’s quite a treasure trove.</p>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a><ul> <li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a><ul>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Developing.html">Developing a Program in Joy</a></li> <li class="toctree-l2"><a class="reference internal" href="notebooks/Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Trees.html">Treating Trees</a></li> <li class="toctree-l2"><a class="reference internal" href="notebooks/Trees.html">Treating Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Newton-Raphson.html">Newton’s method</a></li> <li class="toctree-l2"><a class="reference internal" href="notebooks/Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Quadratic.html">Quadratic formula</a></li> <li class="toctree-l2"><a class="reference internal" href="notebooks/Quadratic.html">Quadratic formula</a></li>

212
docs/sphinx_docs/_build/html/notebooks/4. Replacing Functions in the Dictionary.html
View File

@ -1,212 +0,0 @@
<!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>Replacing Functions in the Dictionary &#8212; Thun 0.1.1 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="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="replacing-functions-in-the-dictionary">
<h1>Replacing Functions in the Dictionary<a class="headerlink" href="#replacing-functions-in-the-dictionary" title="Permalink to this headline"></a></h1>
<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">D</span><span class="p">,</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span>
</pre></div>
</div>
<div class="section" id="a-long-trace">
<h2>A long trace<a class="headerlink" href="#a-long-trace" title="Permalink to this headline"></a></h2>
<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">&#39;[23 18] average&#39;</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="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="n">average</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">app2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">41</span> <span class="o">.</span> <span class="mf">1.0</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">41</span> <span class="mf">1.0</span> <span class="o">.</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="o">.</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="mf">41.0</span><span class="p">]</span> <span class="o">.</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="o">.</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="n">size</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mi">0</span> <span class="o">.</span> <span class="n">swap</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">0</span> <span class="mi">23</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">0</span> <span class="mi">23</span> <span class="o">.</span> <span class="n">pop</span> <span class="o">++</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">0</span> <span class="o">.</span> <span class="o">++</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="o">.</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="p">[</span><span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="mi">18</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="mi">18</span> <span class="o">.</span> <span class="n">pop</span> <span class="o">++</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">1</span> <span class="o">.</span> <span class="o">++</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">2</span> <span class="o">.</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">2</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">.</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="mi">2</span> <span class="o">.</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="mi">2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="o">.</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="o">.</span> <span class="n">popd</span> <span class="mi">2</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="o">.</span> <span class="mi">2</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="mi">2</span> <span class="o">.</span> <span class="o">/</span>
<span class="mf">20.5</span> <span class="o">.</span>
</pre></div>
</div>
</div>
<div class="section" id="replacing-size-with-a-python-version">
<h2>Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python Version<a class="headerlink" href="#replacing-size-with-a-python-version" title="Permalink to this headline"></a></h2>
<p>Both <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> each convert a sequence to a single value.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="nb">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">step</span>
<span class="n">size</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span>
</pre></div>
</div>
<p>An efficient <code class="docutils literal notranslate"><span class="pre">sum</span></code> function is already in the library. But for <code class="docutils literal notranslate"><span class="pre">size</span></code> we can use
a “compiled” version hand-written in Python to speed up evaluation and make the trace more readable.</p>
<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">SimpleFunctionWrapper</span>
<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="k">import</span> <span class="n">iter_stack</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Return the size of the sequence on the stack.&#39;&#39;&#39;</span>
<span class="n">sequence</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">n</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">sequence</span><span class="p">):</span>
<span class="n">n</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">n</span><span class="p">,</span> <span class="n">stack</span>
</pre></div>
</div>
<p>Now we replace the old version in the dictionary with the new version,
and re-evaluate the expression.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">D</span><span class="p">[</span><span class="s1">&#39;size&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">size</span>
</pre></div>
</div>
</div>
<div class="section" id="a-shorter-evaluation">
<h2>A Shorter Evaluation<a class="headerlink" href="#a-shorter-evaluation" title="Permalink to this headline"></a></h2>
<p>You can see that <code class="docutils literal notranslate"><span class="pre">size</span></code> and <code class="docutils literal notranslate"><span class="pre">sum</span></code> now execute in a single step.</p>
<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">&#39;[23 18] average&#39;</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="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="n">average</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="n">cleave</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">app2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="nb">sum</span> <span class="mf">1.0</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">41</span> <span class="o">.</span> <span class="mf">1.0</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">41</span> <span class="mf">1.0</span> <span class="o">.</span> <span class="o">*</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="o">.</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="p">[[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="mf">41.0</span><span class="p">]</span> <span class="o">.</span> <span class="n">first</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="o">.</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[[</span><span class="n">size</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="p">[</span><span class="n">size</span><span class="p">]</span> <span class="o">.</span> <span class="n">i</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="o">.</span> <span class="n">size</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">2</span> <span class="o">.</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="mi">2</span> <span class="p">[</span><span class="mf">41.0</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]]</span> <span class="o">.</span> <span class="n">swaack</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">.</span> <span class="n">first</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="mi">2</span> <span class="o">.</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="mi">2</span> <span class="p">[</span><span class="n">popd</span><span class="p">]</span> <span class="o">.</span> <span class="n">dip</span> <span class="o">/</span>
<span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="mf">41.0</span> <span class="o">.</span> <span class="n">popd</span> <span class="mi">2</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="o">.</span> <span class="mi">2</span> <span class="o">/</span>
<span class="mf">41.0</span> <span class="mi">2</span> <span class="o">.</span> <span class="o">/</span>
<span class="mf">20.5</span> <span class="o">.</span>
</pre></div>
</div>
</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="#">Replacing Functions in the Dictionary</a><ul>
<li><a class="reference internal" href="#a-long-trace">A long trace</a></li>
<li><a class="reference internal" href="#replacing-size-with-a-python-version">Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python Version</a></li>
<li><a class="reference internal" href="#a-shorter-evaluation">A Shorter Evaluation</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="../index.html">Documentation overview</a><ul>
</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/4. Replacing Functions in the Dictionary.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>

4
docs/sphinx_docs/_build/html/notebooks/Developing.html
View File

@ -16,7 +16,7 @@
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></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="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Treating Trees" href="Trees.html" /> <link rel="next" title="Replacing Functions in the Dictionary" href="Replacing.html" />
<link rel="prev" title="Essays about Programming in Joy" href="index.html" /> <link rel="prev" title="Essays about Programming in Joy" href="index.html" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" /> <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
@ -689,7 +689,7 @@ is just:</p>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
<li><a href="index.html">Essays about Programming in Joy</a><ul> <li><a href="index.html">Essays about Programming in Joy</a><ul>
<li>Previous: <a href="index.html" title="previous chapter">Essays about Programming in Joy</a></li> <li>Previous: <a href="index.html" title="previous chapter">Essays about Programming in Joy</a></li>
<li>Next: <a href="Trees.html" title="next chapter">Treating Trees</a></li> <li>Next: <a href="Replacing.html" title="next chapter">Replacing Functions in the Dictionary</a></li>
</ul></li> </ul></li>
</ul></li> </ul></li>
</ul> </ul>

107
docs/sphinx_docs/_build/html/notebooks/Trees.html
View File

@ -17,7 +17,7 @@
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Newton’s method" href="Newton-Raphson.html" /> <link rel="next" title="Newton’s method" href="Newton-Raphson.html" />
<link rel="prev" title="Developing a Program in Joy" href="Developing.html" /> <link rel="prev" title="Replacing Functions in the Dictionary" href="Replacing.html" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" /> <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
@ -967,37 +967,102 @@ because there’s no value to discard. Now we have to derive the branches:</p>
</div> </div>
<div class="section" id="todo-btree-delete"> <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> <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">E</span><span class="p">]</span> <span class="n">BTree</span><span class="o">-</span><span class="n">delete</span> <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="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">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">delete</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="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> <span class="n">tree</span> <span class="n">key</span> <span class="n">Er</span>
</pre></div> </pre></div>
</div> </div>
<p>So:</p> <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="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> <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> </pre></div>
</div> </div>
<p>And:</p> <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>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">n_key</span> <span class="n">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> <span class="o">------------------------------------</span>
<span class="p">[</span><span class="n">n_key</span> <span class="n">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">dup</span> <span class="n">first</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="n">get</span><span class="p">]</span> <span class="n">R1</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">n_key</span> <span class="n">n_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">n_key</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">R1</span> </pre></div>
<span class="p">[</span><span class="n">n_key</span> <span class="n">n_value</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="n">n_key</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">roll</span><span class="o">&gt;</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</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">&lt;</span><span class="p">]</span> <span class="nb">cmp</span> </div>
<span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">n_key</span> <span class="n">key</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</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">&lt;</span><span class="p">]</span> <span class="nb">cmp</span> <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="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">dup</span> <span class="n">first</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="n">roll</span><span class="o">&gt;</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</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">&lt;</span><span class="p">]</span> <span class="nb">cmp</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> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o">&gt;</span> <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">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">E</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">&gt;</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</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">&lt;</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o">&lt;</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">&gt;</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</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">&lt;</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">&gt;</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">&lt;</span><span class="p">]</span> <span class="nb">cmp</span>
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <p>Now this:;</p>
<span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">E</span> <blockquote>
<span class="p">[</span><span class="n">n_key</span> <span class="n">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="n">get</span><span class="p">]</span> <span class="n">T</span><span class="o">&lt;</span> <div>[node_key node_value left right] [key D] node_key key [T&gt;] [E] [T&lt;] cmp</div></blockquote>
<p>Becomes one of these three:;</p>
<blockquote>
<div>[node_key node_value left right] [key D] T&gt;
[node_key node_value left right] [key D] E
[node_key node_value left right] [key D] T&lt;</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">&gt;</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">&gt;</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">&lt;</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">&#39;&#39;&#39;</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"> &#39;&#39;&#39;</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">&lt;</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">&gt;</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> </pre></div>
</div> </div>
</div> </div>
@ -1507,7 +1572,7 @@ because lookup happens at evaluation, not parsing. E.g.:</p>
<ul> <ul>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
<li><a href="index.html">Essays about Programming in Joy</a><ul> <li><a href="index.html">Essays about Programming in Joy</a><ul>
<li>Previous: <a href="Developing.html" title="previous chapter">Developing a Program in Joy</a></li> <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> <li>Next: <a href="Newton-Raphson.html" title="next chapter">Newton’s method</a></li>
</ul></li> </ul></li>
</ul></li> </ul></li>

6
docs/sphinx_docs/_build/html/notebooks/index.html
View File

@ -44,6 +44,12 @@
<li class="toctree-l2"><a class="reference internal" href="Developing.html#the-simplest-program">The Simplest Program</a></li> <li class="toctree-l2"><a class="reference internal" href="Developing.html#the-simplest-program">The Simplest Program</a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a><ul>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html#a-long-trace">A long trace</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html#replacing-size-with-a-python-version">Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python Version</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html#a-shorter-trace">A shorter trace</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="Trees.html">Treating Trees</a><ul> <li class="toctree-l1"><a class="reference internal" href="Trees.html">Treating Trees</a><ul>
<li class="toctree-l2"><a class="reference internal" href="Trees.html#a-function-to-traverse-a-btree">A Function to Traverse a BTree</a></li> <li class="toctree-l2"><a class="reference internal" href="Trees.html#a-function-to-traverse-a-btree">A Function to Traverse a BTree</a></li>
<li class="toctree-l2"><a class="reference internal" href="Trees.html#adding-nodes-to-the-btree">Adding Nodes to the BTree</a></li> <li class="toctree-l2"><a class="reference internal" href="Trees.html#adding-nodes-to-the-btree">Adding Nodes to the BTree</a></li>

BIN
docs/sphinx_docs/_build/html/objects.inv
View File

Binary file not shown.

2
docs/sphinx_docs/_build/html/searchindex.js
View File

File diff suppressed because one or more lines are too long

2
docs/sphinx_docs/notebooks/4. Replacing Functions in the Dictionary.rst → docs/sphinx_docs/notebooks/Replacing.rst
View File

@ -99,7 +99,7 @@ and re-evaluate the expression.
D['size'] = size D['size'] = size
A Shorter Evaluation A shorter trace
~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
You can see that ``size`` and ``sum`` now execute in a single step. You can see that ``size`` and ``sum`` now execute in a single step.

141
docs/sphinx_docs/notebooks/Trees.rst
View File

@ -1210,43 +1210,144 @@ TODO: BTree-delete
:: ::
tree key [E] BTree-delete tree key [Er] BTree-delete
---------------------------- key in tree -------------------------------- key in tree
tree tree
tree key [E] BTree-delete tree key [Er] BTree-delete
---------------------------- key not in tree -------------------------------- key not in tree
tree key E tree key Er
So: So::
BTree-Delete == [pop not] swap [R0] [R1] genrec
:: ::
BTree-delete == [pop not] [] [R0] [R1] genrec [Er] BTree-delete
------------------------------------
[pop not] [Er] [R0] [R1] genrec
And:
Now we get to figure out the recursive case::
D == [pop not] [Er] [R0] [R1] genrec
[node_key node_value left right] key R0 [D] R1
[node_key node_value left right] key over first swap dup [D] R1
[node_key node_value left right] node_key key key [D] R1
:: ::
[n_key n_value left right] key R0 [BTree-get] R1 [node_key node_value left right] node_key key key [D] R1
[n_key n_value left right] key [dup first] dip [BTree-get] R1 [node_key node_value left right] node_key key key [D] cons roll> [T>] [E] [T<] cmp
[n_key n_value left right] n_key key [BTree-get] R1 [node_key node_value left right] node_key key [key D] roll> [T>] [E] [T<] cmp
[n_key n_value left right] n_key key [BTree-get] roll> [T>] [E] [T<] cmp [node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp
[n_key n_value left right] [BTree-get] n_key key [T>] [E] [T<] cmp
Now this:;
[node_key node_value left right] [key D] node_key key [T>] [E] [T<] cmp
Becomes one of these three:;
[node_key node_value left right] [key D] T>
[node_key node_value left right] [key D] E
[node_key node_value left right] [key D] T<
BTree-delete == [pop not] swap [[dup first] dip] [roll> [T>] [E] [T<] cmp] genrec
:: ::
[n_key n_value left right] [BTree-get] T> [node_key node_value left right] [key D] T>
[n_key n_value left right] [BTree-get] E -------------------------------------------------
[n_key n_value left right] [BTree-get] T< [node_key node_value left key D right]
right left node_value node_key [key D] dipd
[node_key node_value left right] [key D] [dipd] cons infra
:: ::
[n_key n_value left right] [BTree-get] T> == [dipd] cons infra
[n_key n_value left right] [BTree-get] E T< == [dipdd] cons infra
[n_key n_value left right] [BTree-get] T<
::
[node_key node_value left right] [key D] E
::
def delete(node, key):
'''
Return a tree with the value (and key) removed or raise KeyError if
not found.
'''
if not node:
raise KeyError, key
node_key, (value, (lower, (higher, _))) = node
if key < node_key:
return node_key, (value, (delete(lower, key), (higher, ())))
if key > node_key:
return node_key, (value, (lower, (delete(higher, key), ())))
# So, key == node_key, delete this node itself.
# If we only have one non-empty child node return it. If both child
# nodes are empty return an empty node (one of the children.)
if not lower:
return higher
if not higher:
return lower
# If both child nodes are non-empty, we find the highest node in our
# lower sub-tree, take its key and value to replace (delete) our own,
# then get rid of it by recursively calling delete() on our lower
# sub-node with our new key.
# (We could also find the lowest node in our higher sub-tree and take
# its key and value and delete it. I only implemented one of these
# two symmetrical options. Over a lot of deletions this might make
# the tree more unbalanced. Oh well.)
node = lower
while node[1][1][1][0]:
node = node[1][1][1][0]
key, value = node[0], node[1][0]
return key, (value, (delete(lower, key), (higher, ())))
Tree with node and list of trees. Tree with node and list of trees.
================================= =================================

1
docs/sphinx_docs/notebooks/index.rst
View File

@ -9,6 +9,7 @@ These essays are adapted from Jupyter notebooks. I hope to have those hosted so
:maxdepth: 2 :maxdepth: 2
Developing Developing
Replacing
Trees Trees
Newton-Raphson Newton-Raphson
Quadratic Quadratic