docs/sphinx_docs/_build/html/_modules/joy/library.html

   1
   2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   3   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   4
   5 <html xmlns="http://www.w3.org/1999/xhtml">
   6   <head>
   7     <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
   8     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   9     <title>joy.library &#8212; Thun 0.4.1 documentation</title>
  10     <link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" />
  11     <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
  12     <script type="text/javascript" src="../../_static/documentation_options.js"></script>
  13     <script type="text/javascript" src="../../_static/jquery.js"></script>
  14     <script type="text/javascript" src="../../_static/underscore.js"></script>
  15     <script type="text/javascript" src="../../_static/doctools.js"></script>
  16     <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
  17     <link rel="index" title="Index" href="../../genindex.html" />
  18     <link rel="search" title="Search" href="../../search.html" />
  19
  20   <link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
  21
  22
  23   <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
  24
  25   </head><body>
  26
  27
  28     <div class="document">
  29       <div class="documentwrapper">
  30         <div class="bodywrapper">
  31           <div class="body" role="main">
  32
  33   <h1>Source code for joy.library</h1><div class="highlight"><pre>
  34 <span></span><span class="c1"># -*- coding: utf-8 -*-</span>
  35 <span class="c1">#</span>
  36 <span class="c1">#    Copyright © 2014-2020 Simon Forman</span>
  37 <span class="c1">#</span>
  38 <span class="c1">#    This file is part of Thun</span>
  39 <span class="c1">#</span>
  40 <span class="c1">#    Thun is free software: you can redistribute it and/or modify</span>
  41 <span class="c1">#    it under the terms of the GNU General Public License as published by</span>
  42 <span class="c1">#    the Free Software Foundation, either version 3 of the License, or</span>
  43 <span class="c1">#    (at your option) any later version.</span>
  44 <span class="c1">#</span>
  45 <span class="c1">#    Thun is distributed in the hope that it will be useful,</span>
  46 <span class="c1">#    but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
  47 <span class="c1">#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
  48 <span class="c1">#    GNU General Public License for more details.</span>
  49 <span class="c1">#</span>
  50 <span class="c1">#    You should have received a copy of the GNU General Public License</span>
  51 <span class="c1">#    along with Thun.  If not see &lt;http://www.gnu.org/licenses/&gt;. </span>
  52 <span class="c1">#</span>
  53 <span class="sd">&#39;&#39;&#39;</span>
  54 <span class="sd">This module contains the Joy function infrastructure and a library of</span>
  55 <span class="sd">functions.  Its main export is a Python function initialize() that</span>
  56 <span class="sd">returns a dictionary of Joy functions suitable for use with the joy()</span>
  57 <span class="sd">function.</span>
  58 <span class="sd">&#39;&#39;&#39;</span>
  59 <span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getdoc</span><span class="p">,</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span>
  60 <span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span>
  61 <span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">count</span>
  62 <span class="kn">import</span> <span class="nn">operator</span><span class="o">,</span> <span class="nn">math</span>
  63
  64 <span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">Symbol</span>
  65 <span class="kn">from</span> <span class="nn">.utils</span> <span class="k">import</span> <span class="n">generated_library</span> <span class="k">as</span> <span class="n">genlib</span>
  66 <span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="p">(</span>
  67         <span class="n">concat</span><span class="p">,</span>
  68         <span class="n">expression_to_string</span><span class="p">,</span>
  69         <span class="n">iter_stack</span><span class="p">,</span>
  70         <span class="n">list_to_stack</span><span class="p">,</span>
  71         <span class="n">pick</span><span class="p">,</span>
  72         <span class="p">)</span>
  73
  74
  75 <span class="n">HELP_TEMPLATE</span> <span class="o">=</span> <span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
  76
  77 <span class="s1">==== Help on </span><span class="si">%s</span><span class="s1"> ====</span>
  78
  79 <span class="si">%s</span><span class="s1"></span>
  80
  81 <span class="s1">---- end (</span><span class="si">%s</span><span class="s1">)</span>
  82 <span class="s1">&#39;&#39;&#39;</span>
  83
  84
  85 <span class="c1"># This is the main dict we&#39;re building.</span>
  86 <span class="n">_dictionary</span> <span class="o">=</span> <span class="p">{}</span>
  87
  88
  89 <div class="viewcode-block" id="inscribe"><a class="viewcode-back" href="../../library.html#joy.library.inscribe">[docs]</a><span class="k">def</span> <span class="nf">inscribe</span><span class="p">(</span><span class="n">function</span><span class="p">):</span>
  90         <span class="sd">&#39;&#39;&#39;A decorator to inscribe functions into the default dictionary.&#39;&#39;&#39;</span>
  91         <span class="n">_dictionary</span><span class="p">[</span><span class="n">function</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">function</span>
  92         <span class="k">return</span> <span class="n">function</span></div>
  93
  94
  95 <div class="viewcode-block" id="initialize"><a class="viewcode-back" href="../../library.html#joy.library.initialize">[docs]</a><span class="k">def</span> <span class="nf">initialize</span><span class="p">():</span>
  96         <span class="sd">&#39;&#39;&#39;Return a dictionary of Joy functions for use with joy().&#39;&#39;&#39;</span>
  97         <span class="k">return</span> <span class="n">_dictionary</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span></div>
  98
  99
 100 <span class="n">ALIASES</span> <span class="o">=</span> <span class="p">(</span>
 101         <span class="p">(</span><span class="s1">&#39;add&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;+&#39;</span><span class="p">]),</span>
 102         <span class="p">(</span><span class="s1">&#39;and&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&amp;&#39;</span><span class="p">]),</span>
 103         <span class="p">(</span><span class="s1">&#39;bool&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;truthy&#39;</span><span class="p">]),</span>
 104         <span class="p">(</span><span class="s1">&#39;mul&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;*&#39;</span><span class="p">]),</span>
 105         <span class="p">(</span><span class="s1">&#39;floordiv&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;/floor&#39;</span><span class="p">,</span> <span class="s1">&#39;//&#39;</span><span class="p">]),</span>
 106         <span class="p">(</span><span class="s1">&#39;truediv&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="s1">&#39;div&#39;</span><span class="p">]),</span>
 107         <span class="p">(</span><span class="s1">&#39;mod&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;%&#39;</span><span class="p">,</span> <span class="s1">&#39;rem&#39;</span><span class="p">,</span> <span class="s1">&#39;remainder&#39;</span><span class="p">,</span> <span class="s1">&#39;modulus&#39;</span><span class="p">]),</span>
 108         <span class="p">(</span><span class="s1">&#39;eq&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;=&#39;</span><span class="p">]),</span>
 109         <span class="p">(</span><span class="s1">&#39;ge&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&gt;=&#39;</span><span class="p">]),</span>
 110         <span class="p">(</span><span class="s1">&#39;getitem&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;pick&#39;</span><span class="p">,</span> <span class="s1">&#39;at&#39;</span><span class="p">]),</span>
 111         <span class="p">(</span><span class="s1">&#39;gt&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&gt;&#39;</span><span class="p">]),</span>
 112         <span class="p">(</span><span class="s1">&#39;le&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&lt;=&#39;</span><span class="p">]),</span>
 113         <span class="p">(</span><span class="s1">&#39;lshift&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&lt;&lt;&#39;</span><span class="p">]),</span>
 114         <span class="p">(</span><span class="s1">&#39;lt&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&lt;&#39;</span><span class="p">]),</span>
 115         <span class="p">(</span><span class="s1">&#39;ne&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&lt;&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;!=&#39;</span><span class="p">]),</span>
 116         <span class="p">(</span><span class="s1">&#39;rshift&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&gt;&gt;&#39;</span><span class="p">]),</span>
 117         <span class="p">(</span><span class="s1">&#39;sub&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;-&#39;</span><span class="p">]),</span>
 118         <span class="p">(</span><span class="s1">&#39;xor&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;^&#39;</span><span class="p">]),</span>
 119         <span class="p">(</span><span class="s1">&#39;succ&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;++&#39;</span><span class="p">]),</span>
 120         <span class="p">(</span><span class="s1">&#39;pred&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;--&#39;</span><span class="p">]),</span>
 121         <span class="p">(</span><span class="s1">&#39;rolldown&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&lt;&#39;</span><span class="p">]),</span>
 122         <span class="p">(</span><span class="s1">&#39;rollup&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&gt;&#39;</span><span class="p">]),</span>
 123         <span class="p">(</span><span class="s1">&#39;eh&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;?&#39;</span><span class="p">]),</span>
 124         <span class="p">(</span><span class="s1">&#39;id&#39;</span><span class="p">,</span> <span class="p">[</span><span class="sa">u</span><span class="s1">&#39;•&#39;</span><span class="p">]),</span>
 125         <span class="p">)</span>
 126
 127
 128 <div class="viewcode-block" id="add_aliases"><a class="viewcode-back" href="../../library.html#joy.library.add_aliases">[docs]</a><span class="k">def</span> <span class="nf">add_aliases</span><span class="p">(</span><span class="n">D</span><span class="p">,</span> <span class="n">A</span><span class="p">):</span>
 129         <span class="sd">&#39;&#39;&#39;</span>
 130 <span class="sd">       Given a dict and a iterable of (name, [alias, ...]) pairs, create</span>
 131 <span class="sd">       additional entries in the dict mapping each alias to the named function</span>
 132 <span class="sd">       if it&#39;s in the dict.  Aliases for functions not in the dict are ignored.</span>
 133 <span class="sd">       &#39;&#39;&#39;</span>
 134         <span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">aliases</span> <span class="ow">in</span> <span class="n">A</span><span class="p">:</span>
 135                 <span class="k">try</span><span class="p">:</span>
 136                         <span class="n">F</span> <span class="o">=</span> <span class="n">D</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
 137                 <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
 138                         <span class="k">continue</span>
 139                 <span class="k">for</span> <span class="n">alias</span> <span class="ow">in</span> <span class="n">aliases</span><span class="p">:</span>
 140                         <span class="n">D</span><span class="p">[</span><span class="n">alias</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div>
 141
 142
 143 <span class="n">definitions</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
 144 <span class="s1">? dup truthy</span>
 145 <span class="s1">*fraction [uncons] dip uncons [swap] dip concat [*] infra [*] dip cons</span>
 146 <span class="s1">*fraction0 concat [[swap] dip * [*] dip] infra</span>
 147 <span class="s1">anamorphism [pop []] swap [dip swons] genrec</span>
 148 <span class="s1">average [sum 1.0 *] [size] cleave /</span>
 149 <span class="s1">binary nullary [popop] dip</span>
 150 <span class="s1">cleave fork [popd] dip</span>
 151 <span class="s1">codireco cons dip rest cons</span>
 152 <span class="s1">dinfrirst dip infra first</span>
 153 <span class="s1">unstack ? [uncons ?] loop pop</span>
 154 <span class="s1">down_to_zero [0 &gt;] [dup --] while</span>
 155 <span class="s1">dupdipd dup dipd</span>
 156 <span class="s1">enstacken stack [clear] dip</span>
 157 <span class="s1">flatten [] swap [concat] step</span>
 158 <span class="s1">fork [i] app2</span>
 159 <span class="s1">gcd 1 [tuck modulus dup 0 &gt;] loop pop</span>
 160 <span class="s1">ifte [nullary not] dipd branch</span>
 161 <span class="s1">ii [dip] dupdip i</span>
 162 <span class="s1">least_fraction dup [gcd] infra [div] concat map</span>
 163 <span class="s1">make_generator [codireco] ccons</span>
 164 <span class="s1">nullary [stack] dinfrirst</span>
 165 <span class="s1">of swap at</span>
 166 <span class="s1">pam [i] map</span>
 167 <span class="s1">tailrec [i] genrec</span>
 168 <span class="s1">product 1 swap [*] step</span>
 169 <span class="s1">quoted [unit] dip</span>
 170 <span class="s1">range [0 &lt;=] [1 - dup] anamorphism</span>
 171 <span class="s1">range_to_zero unit [down_to_zero] infra</span>
 172 <span class="s1">run [] swap infra</span>
 173 <span class="s1">size 0 swap [pop ++] step</span>
 174 <span class="s1">sqr dup mul</span>
 175 <span class="s1">step_zero 0 roll&gt; step</span>
 176 <span class="s1">swoncat swap concat</span>
 177 <span class="s1">tailrec [i] genrec</span>
 178 <span class="s1">ternary unary [popop] dip</span>
 179 <span class="s1">unary nullary popd</span>
 180 <span class="s1">unquoted [i] dip</span>
 181 <span class="s1">while swap [nullary] cons dup dipd concat loop</span>
 182 <span class="s1">&#39;&#39;&#39;</span>
 183 <span class="c1">#</span>
 184 <span class="c1">#</span>
 185 <span class="c1"># ifte == [nullary] dipd swap branch</span>
 186 <span class="c1"># genrec == [[genrec] cons cons cons cons] nullary swons concat ifte</span>
 187
 188 <span class="c1"># Another definition for while. FWIW</span>
 189 <span class="c1"># while == over [[i] dip nullary] ccons [nullary] dip loop</span>
 190
 191 <span class="c1">##ccons == cons cons</span>
 192 <span class="c1">##unit == [] cons</span>
 193 <span class="c1">##second == rest first</span>
 194 <span class="c1">##third == rest rest first</span>
 195 <span class="c1">##swons == swap cons</span>
 196
 197 <span class="c1">##Zipper</span>
 198 <span class="c1">##z-down == [] swap uncons swap</span>
 199 <span class="c1">##z-up == swons swap shunt</span>
 200 <span class="c1">##z-right == [swons] cons dip uncons swap</span>
 201 <span class="c1">##z-left == swons [uncons swap] dip swap</span>
 202
 203 <span class="c1">##Quadratic Formula</span>
 204 <span class="c1">##divisor == popop 2 *</span>
 205 <span class="c1">##minusb == pop neg</span>
 206 <span class="c1">##radical == swap dup * rollup * 4 * - sqrt</span>
 207 <span class="c1">##root1 == + swap /</span>
 208 <span class="c1">##root2 == - swap /</span>
 209 <span class="c1">##q0 == [[divisor] [minusb] [radical]] pam</span>
 210 <span class="c1">##q1 == [[root1] [root2]] pam</span>
 211 <span class="c1">##quadratic == [q0] ternary i [q1] ternary</span>
 212
 213 <span class="c1"># Project Euler</span>
 214 <span class="c1">##&#39;&#39;&#39;\</span>
 215 <span class="c1">##PE1.1 == + dup [+] dip</span>
 216 <span class="c1">##PE1.2 == dup [3 &amp; PE1.1] dip 2 &gt;&gt;</span>
 217 <span class="c1">##PE1.3 == 14811 swap [PE1.2] times pop</span>
 218 <span class="c1">##PE1 == 0 0 66 [7 PE1.3] times 4 PE1.3 pop</span>
 219 <span class="c1">##&#39;&#39;&#39;</span>
 220 <span class="c1">#PE1.2 == [PE1.1] step</span>
 221 <span class="c1">#PE1 == 0 0 66 [[3 2 1 3 1 2 3] PE1.2] times [3 2 1 3] PE1.2 pop</span>
 222 <span class="p">)</span>
 223
 224
 225 <div class="viewcode-block" id="FunctionWrapper"><a class="viewcode-back" href="../../library.html#joy.library.FunctionWrapper">[docs]</a><span class="k">def</span> <span class="nf">FunctionWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
 226         <span class="sd">&#39;&#39;&#39;Set name attribute.&#39;&#39;&#39;</span>
 227         <span class="k">if</span> <span class="ow">not</span> <span class="n">f</span><span class="o">.</span><span class="vm">__doc__</span><span class="p">:</span>
 228                 <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;Function </span><span class="si">%s</span><span class="s1"> must have doc string.&#39;</span> <span class="o">%</span> <span class="n">f</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
 229         <span class="n">f</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="vm">__name__</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s1">&#39;_&#39;</span><span class="p">)</span>  <span class="c1"># Don&#39;t shadow builtins.</span>
 230         <span class="k">return</span> <span class="n">f</span></div>
 231
 232
 233 <div class="viewcode-block" id="SimpleFunctionWrapper"><a class="viewcode-back" href="../../library.html#joy.library.SimpleFunctionWrapper">[docs]</a><span class="k">def</span> <span class="nf">SimpleFunctionWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
 234         <span class="sd">&#39;&#39;&#39;</span>
 235 <span class="sd">       Wrap functions that take and return just a stack.</span>
 236 <span class="sd">       &#39;&#39;&#39;</span>
 237         <span class="nd">@FunctionWrapper</span>
 238         <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
 239         <span class="k">def</span> <span class="nf">inner</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 240                 <span class="k">return</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
 241         <span class="k">return</span> <span class="n">inner</span></div>
 242
 243
 244 <div class="viewcode-block" id="BinaryBuiltinWrapper"><a class="viewcode-back" href="../../library.html#joy.library.BinaryBuiltinWrapper">[docs]</a><span class="k">def</span> <span class="nf">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
 245         <span class="sd">&#39;&#39;&#39;</span>
 246 <span class="sd">       Wrap functions that take two arguments and return a single result.</span>
 247 <span class="sd">       &#39;&#39;&#39;</span>
 248         <span class="nd">@FunctionWrapper</span>
 249         <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
 250         <span class="k">def</span> <span class="nf">inner</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 251                 <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 252                 <span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="p">)</span>
 253                 <span class="k">return</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
 254         <span class="k">return</span> <span class="n">inner</span></div>
 255
 256
 257 <div class="viewcode-block" id="UnaryBuiltinWrapper"><a class="viewcode-back" href="../../library.html#joy.library.UnaryBuiltinWrapper">[docs]</a><span class="k">def</span> <span class="nf">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
 258         <span class="sd">&#39;&#39;&#39;</span>
 259 <span class="sd">       Wrap functions that take one argument and return a single result.</span>
 260 <span class="sd">       &#39;&#39;&#39;</span>
 261         <span class="nd">@FunctionWrapper</span>
 262         <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
 263         <span class="k">def</span> <span class="nf">inner</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 264                 <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
 265                 <span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
 266                 <span class="k">return</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
 267         <span class="k">return</span> <span class="n">inner</span></div>
 268
 269
 270 <div class="viewcode-block" id="DefinitionWrapper"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper">[docs]</a><span class="k">class</span> <span class="nc">DefinitionWrapper</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
 271         <span class="sd">&#39;&#39;&#39;</span>
 272 <span class="sd">       Provide implementation of defined functions, and some helper methods.</span>
 273 <span class="sd">       &#39;&#39;&#39;</span>
 274
 275         <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">body_text</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
 276                 <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__name__</span> <span class="o">=</span> <span class="n">name</span>
 277                 <span class="bp">self</span><span class="o">.</span><span class="n">body</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">body_text</span><span class="p">)</span>
 278                 <span class="bp">self</span><span class="o">.</span><span class="n">_body</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">body</span><span class="p">))</span>
 279                 <span class="bp">self</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="n">doc</span> <span class="ow">or</span> <span class="n">body_text</span>
 280                 <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span> <span class="o">=</span> <span class="kc">None</span>
 281
 282         <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 283                 <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">:</span>
 284                         <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span>  <span class="c1"># pylint: disable=E1102</span>
 285                 <span class="n">expression</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_body</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
 286                 <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
 287
 288 <div class="viewcode-block" id="DefinitionWrapper.parse_definition"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper.parse_definition">[docs]</a>        <span class="nd">@classmethod</span>
 289         <span class="k">def</span> <span class="nf">parse_definition</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">defi</span><span class="p">):</span>
 290                 <span class="sd">&#39;&#39;&#39;</span>
 291 <span class="sd">               Given some text describing a Joy function definition parse it and</span>
 292 <span class="sd">               return a DefinitionWrapper.</span>
 293 <span class="sd">               &#39;&#39;&#39;</span>
 294                 <span class="k">return</span> <span class="n">class_</span><span class="p">(</span><span class="o">*</span><span class="p">(</span><span class="n">n</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">defi</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="mi">1</span><span class="p">)))</span></div>
 295
 296 <div class="viewcode-block" id="DefinitionWrapper.add_definitions"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper.add_definitions">[docs]</a>  <span class="nd">@classmethod</span>
 297         <span class="k">def</span> <span class="nf">add_definitions</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">defs</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 298                 <span class="sd">&#39;&#39;&#39;</span>
 299 <span class="sd">               Scan multi-line string defs for definitions and add them to the</span>
 300 <span class="sd">               dictionary.</span>
 301 <span class="sd">               &#39;&#39;&#39;</span>
 302                 <span class="k">for</span> <span class="n">definition</span> <span class="ow">in</span> <span class="n">_text_to_defs</span><span class="p">(</span><span class="n">defs</span><span class="p">):</span>
 303                         <span class="n">class_</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span></div>
 304
 305 <div class="viewcode-block" id="DefinitionWrapper.add_def"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper.add_def">[docs]</a>  <span class="nd">@classmethod</span>
 306         <span class="k">def</span> <span class="nf">add_def</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">fail_fails</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
 307                 <span class="sd">&#39;&#39;&#39;</span>
 308 <span class="sd">               Add the definition to the dictionary.</span>
 309 <span class="sd">               &#39;&#39;&#39;</span>
 310                 <span class="n">F</span> <span class="o">=</span> <span class="n">class_</span><span class="o">.</span><span class="n">parse_definition</span><span class="p">(</span><span class="n">definition</span><span class="p">)</span>
 311                 <span class="n">dictionary</span><span class="p">[</span><span class="n">F</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div>
 312
 313         <span class="nd">@classmethod</span>
 314         <span class="k">def</span> <span class="nf">load_definitions</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 315                 <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
 316                         <span class="n">lines</span> <span class="o">=</span> <span class="p">[</span><span class="n">line</span> <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">f</span> <span class="k">if</span> <span class="s1">&#39;==&#39;</span> <span class="ow">in</span> <span class="n">line</span><span class="p">]</span>
 317                 <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span><span class="p">:</span>
 318                         <span class="n">class_</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">line</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span></div>
 319
 320
 321 <span class="k">def</span> <span class="nf">_text_to_defs</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
 322         <span class="k">return</span> <span class="p">(</span>
 323                 <span class="n">line</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
 324                 <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">()</span>
 325                 <span class="k">if</span> <span class="n">line</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">line</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;#&#39;</span><span class="p">)</span>
 326                 <span class="p">)</span>
 327
 328
 329 <span class="c1">#</span>
 330 <span class="c1"># Functions</span>
 331 <span class="c1">#</span>
 332
 333
 334 <div class="viewcode-block" id="inscribe_"><a class="viewcode-back" href="../../library.html#joy.library.inscribe_">[docs]</a><span class="nd">@inscribe</span>
 335 <span class="nd">@FunctionWrapper</span>
 336 <span class="k">def</span> <span class="nf">inscribe_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 337         <span class="sd">&#39;&#39;&#39;</span>
 338 <span class="sd">       Create a new Joy function definition in the Joy dictionary.  A</span>
 339 <span class="sd">       definition is given as a string with a name followed by a double</span>
 340 <span class="sd">       equal sign then one or more Joy functions, the body. for example:</span>
 341
 342 <span class="sd">               sqr == dup mul</span>
 343
 344 <span class="sd">       If you want the definition to persist over restarts, enter it into</span>
 345 <span class="sd">       the definitions.txt resource.</span>
 346 <span class="sd">       &#39;&#39;&#39;</span>
 347         <span class="n">definition</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
 348         <span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">fail_fails</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
 349         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 350
 351
 352 <div class="viewcode-block" id="parse"><a class="viewcode-back" href="../../library.html#joy.library.parse">[docs]</a><span class="nd">@inscribe</span>
 353 <span class="nd">@SimpleFunctionWrapper</span>
 354 <span class="k">def</span> <span class="nf">parse</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 355         <span class="sd">&#39;&#39;&#39;Parse the string on the stack to a Joy expression.&#39;&#39;&#39;</span>
 356         <span class="n">text</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
 357         <span class="n">expression</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
 358         <span class="k">return</span> <span class="n">expression</span><span class="p">,</span> <span class="n">stack</span></div>
 359
 360
 361 <span class="c1"># @inscribe</span>
 362 <span class="c1"># @SimpleFunctionWrapper</span>
 363 <span class="c1"># def infer_(stack):</span>
 364 <span class="c1">#      &#39;&#39;&#39;Attempt to infer the stack effect of a Joy expression.&#39;&#39;&#39;</span>
 365 <span class="c1">#      E, stack = stack</span>
 366 <span class="c1">#      effects = infer_expression(E)</span>
 367 <span class="c1">#      e = list_to_stack([(fi, (fo, ())) for fi, fo in effects])</span>
 368 <span class="c1">#      return e, stack</span>
 369
 370
 371 <div class="viewcode-block" id="getitem"><a class="viewcode-back" href="../../library.html#joy.library.getitem">[docs]</a><span class="nd">@inscribe</span>
 372 <span class="nd">@SimpleFunctionWrapper</span>
 373 <span class="k">def</span> <span class="nf">getitem</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 374         <span class="sd">&#39;&#39;&#39;</span>
 375 <span class="sd">       ::</span>
 376
 377 <span class="sd">               getitem == drop first</span>
 378
 379 <span class="sd">       Expects an integer and a quote on the stack and returns the item at the</span>
 380 <span class="sd">       nth position in the quote counting from 0.</span>
 381 <span class="sd">       ::</span>
 382
 383 <span class="sd">                  [a b c d] 0 getitem</span>
 384 <span class="sd">               -------------------------</span>
 385 <span class="sd">                   a</span>
 386
 387 <span class="sd">       &#39;&#39;&#39;</span>
 388         <span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
 389         <span class="k">return</span> <span class="n">pick</span><span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">n</span><span class="p">),</span> <span class="n">stack</span></div>
 390
 391
 392 <div class="viewcode-block" id="drop"><a class="viewcode-back" href="../../library.html#joy.library.drop">[docs]</a><span class="nd">@inscribe</span>
 393 <span class="nd">@SimpleFunctionWrapper</span>
 394 <span class="k">def</span> <span class="nf">drop</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 395         <span class="sd">&#39;&#39;&#39;</span>
 396 <span class="sd">       ::</span>
 397
 398 <span class="sd">               drop == [rest] times</span>
 399
 400 <span class="sd">       Expects an integer and a quote on the stack and returns the quote with</span>
 401 <span class="sd">       n items removed off the top.</span>
 402 <span class="sd">       ::</span>
 403
 404 <span class="sd">                  [a b c d] 2 drop</span>
 405 <span class="sd">               ----------------------</span>
 406 <span class="sd">                      [c d]</span>
 407
 408 <span class="sd">       &#39;&#39;&#39;</span>
 409         <span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
 410         <span class="k">while</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
 411                 <span class="k">try</span><span class="p">:</span>
 412                         <span class="n">_</span><span class="p">,</span> <span class="n">Q</span> <span class="o">=</span> <span class="n">Q</span>
 413                 <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
 414                         <span class="k">raise</span> <span class="ne">IndexError</span>
 415                 <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
 416         <span class="k">return</span> <span class="n">Q</span><span class="p">,</span> <span class="n">stack</span></div>
 417
 418
 419 <div class="viewcode-block" id="take"><a class="viewcode-back" href="../../library.html#joy.library.take">[docs]</a><span class="nd">@inscribe</span>
 420 <span class="nd">@SimpleFunctionWrapper</span>
 421 <span class="k">def</span> <span class="nf">take</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 422         <span class="sd">&#39;&#39;&#39;</span>
 423 <span class="sd">       Expects an integer and a quote on the stack and returns the quote with</span>
 424 <span class="sd">       just the top n items in reverse order (because that&#39;s easier and you can</span>
 425 <span class="sd">       use reverse if needed.)</span>
 426 <span class="sd">       ::</span>
 427
 428 <span class="sd">                  [a b c d] 2 take</span>
 429 <span class="sd">               ----------------------</span>
 430 <span class="sd">                      [b a]</span>
 431
 432 <span class="sd">       &#39;&#39;&#39;</span>
 433         <span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
 434         <span class="n">x</span> <span class="o">=</span> <span class="p">()</span>
 435         <span class="k">while</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
 436                 <span class="k">try</span><span class="p">:</span>
 437                         <span class="n">item</span><span class="p">,</span> <span class="n">Q</span> <span class="o">=</span> <span class="n">Q</span>
 438                 <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
 439                         <span class="k">raise</span> <span class="ne">IndexError</span>
 440                 <span class="n">x</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">x</span>
 441                 <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
 442         <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">stack</span></div>
 443
 444
 445 <div class="viewcode-block" id="choice"><a class="viewcode-back" href="../../library.html#joy.library.choice">[docs]</a><span class="nd">@inscribe</span>
 446 <span class="nd">@SimpleFunctionWrapper</span>
 447 <span class="k">def</span> <span class="nf">choice</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 448         <span class="sd">&#39;&#39;&#39;</span>
 449 <span class="sd">       Use a Boolean value to select one of two items.</span>
 450 <span class="sd">       ::</span>
 451
 452 <span class="sd">                  A B False choice</span>
 453 <span class="sd">               ----------------------</span>
 454 <span class="sd">                  A</span>
 455
 456
 457 <span class="sd">                  A B True choice</span>
 458 <span class="sd">               ---------------------</span>
 459 <span class="sd">                    B</span>
 460
 461 <span class="sd">       Currently Python semantics are used to evaluate the &quot;truthiness&quot; of the</span>
 462 <span class="sd">       Boolean value (so empty string, zero, etc. are counted as false, etc.)</span>
 463 <span class="sd">       &#39;&#39;&#39;</span>
 464         <span class="p">(</span><span class="n">if_</span><span class="p">,</span> <span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">stack</span>
 465         <span class="k">return</span> <span class="n">then</span> <span class="k">if</span> <span class="n">if_</span> <span class="k">else</span> <span class="n">else_</span><span class="p">,</span> <span class="n">stack</span></div>
 466
 467
 468 <div class="viewcode-block" id="select"><a class="viewcode-back" href="../../library.html#joy.library.select">[docs]</a><span class="nd">@inscribe</span>
 469 <span class="nd">@SimpleFunctionWrapper</span>
 470 <span class="k">def</span> <span class="nf">select</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 471         <span class="sd">&#39;&#39;&#39;</span>
 472 <span class="sd">       Use a Boolean value to select one of two items from a sequence.</span>
 473 <span class="sd">       ::</span>
 474
 475 <span class="sd">                  [A B] False select</span>
 476 <span class="sd">               ------------------------</span>
 477 <span class="sd">                   A</span>
 478
 479
 480 <span class="sd">                  [A B] True select</span>
 481 <span class="sd">               -----------------------</span>
 482 <span class="sd">                     B</span>
 483
 484 <span class="sd">       The sequence can contain more than two items but not fewer.</span>
 485 <span class="sd">       Currently Python semantics are used to evaluate the &quot;truthiness&quot; of the</span>
 486 <span class="sd">       Boolean value (so empty string, zero, etc. are counted as false, etc.)</span>
 487 <span class="sd">       &#39;&#39;&#39;</span>
 488         <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="p">(</span><span class="n">choices</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 489         <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="n">_</span><span class="p">))</span> <span class="o">=</span> <span class="n">choices</span>
 490         <span class="k">return</span> <span class="n">then</span> <span class="k">if</span> <span class="n">flag</span> <span class="k">else</span> <span class="n">else_</span><span class="p">,</span> <span class="n">stack</span></div>
 491
 492
 493 <div class="viewcode-block" id="max_"><a class="viewcode-back" href="../../library.html#joy.library.max_">[docs]</a><span class="nd">@inscribe</span>
 494 <span class="nd">@SimpleFunctionWrapper</span>
 495 <span class="k">def</span> <span class="nf">max_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 496         <span class="sd">&#39;&#39;&#39;Given a list find the maximum.&#39;&#39;&#39;</span>
 497         <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
 498         <span class="k">return</span> <span class="nb">max</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">)),</span> <span class="n">stack</span></div>
 499
 500
 501 <div class="viewcode-block" id="min_"><a class="viewcode-back" href="../../library.html#joy.library.min_">[docs]</a><span class="nd">@inscribe</span>
 502 <span class="nd">@SimpleFunctionWrapper</span>
 503 <span class="k">def</span> <span class="nf">min_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 504         <span class="sd">&#39;&#39;&#39;Given a list find the minimum.&#39;&#39;&#39;</span>
 505         <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
 506         <span class="k">return</span> <span class="nb">min</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">)),</span> <span class="n">stack</span></div>
 507
 508
 509 <div class="viewcode-block" id="sum_"><a class="viewcode-back" href="../../library.html#joy.library.sum_">[docs]</a><span class="nd">@inscribe</span>
 510 <span class="nd">@SimpleFunctionWrapper</span>
 511 <span class="k">def</span> <span class="nf">sum_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 512         <span class="sd">&#39;&#39;&#39;</span>
 513 <span class="sd">       Given a quoted sequence of numbers return the sum.</span>
 514 <span class="sd">       ::</span>
 515
 516 <span class="sd">               sum == 0 swap [+] step</span>
 517
 518 <span class="sd">       &#39;&#39;&#39;</span>
 519         <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
 520         <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">)),</span> <span class="n">stack</span></div>
 521
 522
 523 <div class="viewcode-block" id="remove"><a class="viewcode-back" href="../../library.html#joy.library.remove">[docs]</a><span class="nd">@inscribe</span>
 524 <span class="nd">@SimpleFunctionWrapper</span>
 525 <span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 526         <span class="sd">&#39;&#39;&#39;</span>
 527 <span class="sd">       Expects an item on the stack and a quote under it and removes that item</span>
 528 <span class="sd">       from the the quote.  The item is only removed once.</span>
 529 <span class="sd">       ::</span>
 530
 531 <span class="sd">                  [1 2 3 1] 1 remove</span>
 532 <span class="sd">               ------------------------</span>
 533 <span class="sd">                    [2 3 1]</span>
 534
 535 <span class="sd">       &#39;&#39;&#39;</span>
 536         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
 537         <span class="n">l</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">second</span><span class="p">))</span>
 538         <span class="n">l</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">tos</span><span class="p">)</span>
 539         <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">l</span><span class="p">),</span> <span class="n">stack</span></div>
 540
 541
 542 <div class="viewcode-block" id="unique"><a class="viewcode-back" href="../../library.html#joy.library.unique">[docs]</a><span class="nd">@inscribe</span>
 543 <span class="nd">@SimpleFunctionWrapper</span>
 544 <span class="k">def</span> <span class="nf">unique</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 545         <span class="sd">&#39;&#39;&#39;Given a list remove duplicate items.&#39;&#39;&#39;</span>
 546         <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
 547         <span class="n">I</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))</span>
 548         <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">I</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="n">I</span><span class="o">.</span><span class="n">index</span><span class="p">)),</span> <span class="n">stack</span></div>
 549
 550
 551 <div class="viewcode-block" id="sort_"><a class="viewcode-back" href="../../library.html#joy.library.sort_">[docs]</a><span class="nd">@inscribe</span>
 552 <span class="nd">@SimpleFunctionWrapper</span>
 553 <span class="k">def</span> <span class="nf">sort_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 554         <span class="sd">&#39;&#39;&#39;Given a list return it sorted.&#39;&#39;&#39;</span>
 555         <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
 556         <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))),</span> <span class="n">stack</span></div>
 557
 558
 559 <div class="viewcode-block" id="clear"><a class="viewcode-back" href="../../library.html#joy.library.clear">[docs]</a><span class="nd">@inscribe</span>
 560 <span class="nd">@SimpleFunctionWrapper</span>
 561 <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 562         <span class="sd">&#39;&#39;&#39;Clear everything from the stack.</span>
 563 <span class="sd">       ::</span>
 564
 565 <span class="sd">               clear == stack [pop stack] loop</span>
 566
 567 <span class="sd">                  ... clear</span>
 568 <span class="sd">               ---------------</span>
 569
 570 <span class="sd">       &#39;&#39;&#39;</span>
 571         <span class="k">return</span> <span class="p">()</span></div>
 572
 573
 574 <div class="viewcode-block" id="disenstacken"><a class="viewcode-back" href="../../library.html#joy.library.disenstacken">[docs]</a><span class="nd">@inscribe</span>
 575 <span class="nd">@SimpleFunctionWrapper</span>
 576 <span class="k">def</span> <span class="nf">disenstacken</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 577         <span class="sd">&#39;&#39;&#39;</span>
 578 <span class="sd">       The disenstacken operator expects a list on top of the stack and makes that</span>
 579 <span class="sd">       the stack discarding the rest of the stack.</span>
 580 <span class="sd">       &#39;&#39;&#39;</span>
 581         <span class="k">return</span> <span class="n">stack</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></div>
 582
 583
 584 <div class="viewcode-block" id="reverse"><a class="viewcode-back" href="../../library.html#joy.library.reverse">[docs]</a><span class="nd">@inscribe</span>
 585 <span class="nd">@SimpleFunctionWrapper</span>
 586 <span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 587         <span class="sd">&#39;&#39;&#39;</span>
 588 <span class="sd">       Reverse the list on the top of the stack.</span>
 589 <span class="sd">       ::</span>
 590
 591 <span class="sd">               reverse == [] swap shunt</span>
 592 <span class="sd">       &#39;&#39;&#39;</span>
 593         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">S</span>
 594         <span class="n">res</span> <span class="o">=</span> <span class="p">()</span>
 595         <span class="k">for</span> <span class="n">term</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">):</span>
 596                 <span class="n">res</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">res</span>
 597         <span class="k">return</span> <span class="n">res</span><span class="p">,</span> <span class="n">stack</span></div>
 598
 599
 600 <div class="viewcode-block" id="concat_"><a class="viewcode-back" href="../../library.html#joy.library.concat_">[docs]</a><span class="nd">@inscribe</span>
 601 <span class="nd">@SimpleFunctionWrapper</span>
 602 <span class="k">def</span> <span class="nf">concat_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 603         <span class="sd">&#39;&#39;&#39;</span>
 604 <span class="sd">       Concatinate the two lists on the top of the stack.</span>
 605 <span class="sd">       ::</span>
 606
 607 <span class="sd">                  [a b c] [d e f] concat</span>
 608 <span class="sd">               ----------------------------</span>
 609 <span class="sd">                      [a b c d e f]</span>
 610
 611 <span class="sd">       &#39;&#39;&#39;</span>
 612         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
 613         <span class="k">return</span> <span class="n">concat</span><span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="n">tos</span><span class="p">),</span> <span class="n">stack</span></div>
 614
 615
 616 <div class="viewcode-block" id="shunt"><a class="viewcode-back" href="../../library.html#joy.library.shunt">[docs]</a><span class="nd">@inscribe</span>
 617 <span class="nd">@SimpleFunctionWrapper</span>
 618 <span class="k">def</span> <span class="nf">shunt</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 619         <span class="sd">&#39;&#39;&#39;</span>
 620 <span class="sd">       Like concat but reverses the top list into the second.</span>
 621 <span class="sd">       ::</span>
 622
 623 <span class="sd">               shunt == [swons] step == reverse swap concat</span>
 624
 625 <span class="sd">                  [a b c] [d e f] shunt</span>
 626 <span class="sd">               ---------------------------</span>
 627 <span class="sd">                      [f e d a b c] </span>
 628
 629 <span class="sd">       &#39;&#39;&#39;</span>
 630         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 631         <span class="k">while</span> <span class="n">tos</span><span class="p">:</span>
 632                 <span class="n">term</span><span class="p">,</span> <span class="n">tos</span> <span class="o">=</span> <span class="n">tos</span>
 633                 <span class="n">second</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">second</span>
 634         <span class="k">return</span> <span class="n">second</span><span class="p">,</span> <span class="n">stack</span></div>
 635
 636
 637 <div class="viewcode-block" id="zip_"><a class="viewcode-back" href="../../library.html#joy.library.zip_">[docs]</a><span class="nd">@inscribe</span>
 638 <span class="nd">@SimpleFunctionWrapper</span>
 639 <span class="k">def</span> <span class="nf">zip_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 640         <span class="sd">&#39;&#39;&#39;</span>
 641 <span class="sd">       Replace the two lists on the top of the stack with a list of the pairs</span>
 642 <span class="sd">       from each list.  The smallest list sets the length of the result list.</span>
 643 <span class="sd">       &#39;&#39;&#39;</span>
 644         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
 645         <span class="n">accumulator</span> <span class="o">=</span> <span class="p">[</span>
 646                 <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">()))</span>
 647                 <span class="k">for</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">),</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">second</span><span class="p">))</span>
 648                 <span class="p">]</span>
 649         <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">accumulator</span><span class="p">),</span> <span class="n">stack</span></div>
 650
 651
 652 <div class="viewcode-block" id="succ"><a class="viewcode-back" href="../../library.html#joy.library.succ">[docs]</a><span class="nd">@inscribe</span>
 653 <span class="nd">@SimpleFunctionWrapper</span>
 654 <span class="k">def</span> <span class="nf">succ</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 655         <span class="sd">&#39;&#39;&#39;Increment TOS.&#39;&#39;&#39;</span>
 656         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">S</span>
 657         <span class="k">return</span> <span class="n">tos</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">stack</span></div>
 658
 659
 660 <div class="viewcode-block" id="pred"><a class="viewcode-back" href="../../library.html#joy.library.pred">[docs]</a><span class="nd">@inscribe</span>
 661 <span class="nd">@SimpleFunctionWrapper</span>
 662 <span class="k">def</span> <span class="nf">pred</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 663         <span class="sd">&#39;&#39;&#39;Decrement TOS.&#39;&#39;&#39;</span>
 664         <span class="p">(</span><span class="n">tos</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">S</span>
 665         <span class="k">return</span> <span class="n">tos</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">stack</span></div>
 666
 667
 668 <div class="viewcode-block" id="pm"><a class="viewcode-back" href="../../library.html#joy.library.pm">[docs]</a><span class="nd">@inscribe</span>
 669 <span class="nd">@SimpleFunctionWrapper</span>
 670 <span class="k">def</span> <span class="nf">pm</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 671         <span class="sd">&#39;&#39;&#39;</span>
 672 <span class="sd">       Plus or minus</span>
 673 <span class="sd">       ::</span>
 674
 675 <span class="sd">                  a b pm</span>
 676 <span class="sd">               -------------</span>
 677 <span class="sd">                  a+b a-b</span>
 678
 679 <span class="sd">       &#39;&#39;&#39;</span>
 680         <span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
 681         <span class="n">p</span><span class="p">,</span> <span class="n">m</span><span class="p">,</span> <span class="o">=</span> <span class="n">b</span> <span class="o">+</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">-</span> <span class="n">a</span>
 682         <span class="k">return</span> <span class="n">m</span><span class="p">,</span> <span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span></div>
 683
 684
 685 <div class="viewcode-block" id="floor"><a class="viewcode-back" href="../../library.html#joy.library.floor">[docs]</a><span class="k">def</span> <span class="nf">floor</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
 686         <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="p">(</span><span class="n">n</span><span class="p">))</span></div>
 687
 688 <span class="n">floor</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="o">.</span><span class="vm">__doc__</span>
 689
 690
 691 <div class="viewcode-block" id="divmod_"><a class="viewcode-back" href="../../library.html#joy.library.divmod_">[docs]</a><span class="nd">@inscribe</span>
 692 <span class="nd">@SimpleFunctionWrapper</span>
 693 <span class="k">def</span> <span class="nf">divmod_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
 694         <span class="sd">&#39;&#39;&#39;</span>
 695 <span class="sd">       divmod(x, y) -&gt; (quotient, remainder)</span>
 696
 697 <span class="sd">       Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.</span>
 698 <span class="sd">       &#39;&#39;&#39;</span>
 699         <span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">S</span>
 700         <span class="n">d</span><span class="p">,</span> <span class="n">m</span> <span class="o">=</span> <span class="nb">divmod</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
 701         <span class="k">return</span> <span class="n">d</span><span class="p">,</span> <span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span></div>
 702
 703
 704 <div class="viewcode-block" id="sqrt"><a class="viewcode-back" href="../../library.html#joy.library.sqrt">[docs]</a><span class="k">def</span> <span class="nf">sqrt</span><span class="p">(</span><span class="n">a</span><span class="p">):</span>
 705         <span class="sd">&#39;&#39;&#39;</span>
 706 <span class="sd">       Return the square root of the number a.</span>
 707 <span class="sd">       Negative numbers return complex roots.</span>
 708 <span class="sd">       &#39;&#39;&#39;</span>
 709         <span class="k">try</span><span class="p">:</span>
 710                 <span class="n">r</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
 711         <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
 712                 <span class="k">assert</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">repr</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
 713                 <span class="n">r</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="o">-</span><span class="n">a</span><span class="p">)</span> <span class="o">*</span> <span class="mi">1</span><span class="n">j</span>
 714         <span class="k">return</span> <span class="n">r</span></div>
 715
 716
 717 <span class="c1">#def execute(S):</span>
 718 <span class="c1">#  (text, stack) = S</span>
 719 <span class="c1">#  if isinstance(text, str):</span>
 720 <span class="c1">#    return run(text, stack)</span>
 721 <span class="c1">#  return stack</span>
 722
 723
 724 <div class="viewcode-block" id="id_"><a class="viewcode-back" href="../../library.html#joy.library.id_">[docs]</a><span class="nd">@inscribe</span>
 725 <span class="nd">@SimpleFunctionWrapper</span>
 726 <span class="k">def</span> <span class="nf">id_</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 727         <span class="sd">&#39;&#39;&#39;The identity function.&#39;&#39;&#39;</span>
 728         <span class="k">return</span> <span class="n">stack</span></div>
 729
 730
 731 <div class="viewcode-block" id="void"><a class="viewcode-back" href="../../library.html#joy.library.void">[docs]</a><span class="nd">@inscribe</span>
 732 <span class="nd">@SimpleFunctionWrapper</span>
 733 <span class="k">def</span> <span class="nf">void</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
 734         <span class="sd">&#39;&#39;&#39;True if the form on TOS is void otherwise False.&#39;&#39;&#39;</span>
 735         <span class="n">form</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
 736         <span class="k">return</span> <span class="n">_void</span><span class="p">(</span><span class="n">form</span><span class="p">),</span> <span class="n">stack</span></div>
 737
 738
 739 <span class="k">def</span> <span class="nf">_void</span><span class="p">(</span><span class="n">form</span><span class="p">):</span>
 740         <span class="k">return</span> <span class="nb">any</span><span class="p">(</span><span class="ow">not</span> <span class="n">_void</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">form</span><span class="p">))</span>
 741
 742
 743
 744 <span class="c1">##  transpose</span>
 745 <span class="c1">##  sign</span>
 746 <span class="c1">##  take</span>
 747
 748
 749 <div class="viewcode-block" id="words"><a class="viewcode-back" href="../../library.html#joy.library.words">[docs]</a><span class="nd">@inscribe</span>
 750 <span class="nd">@FunctionWrapper</span>
 751 <span class="k">def</span> <span class="nf">words</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 752         <span class="sd">&#39;&#39;&#39;Print all the words in alphabetical order.&#39;&#39;&#39;</span>
 753         <span class="nb">print</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">dictionary</span><span class="p">)))</span>
 754         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 755
 756
 757 <div class="viewcode-block" id="sharing"><a class="viewcode-back" href="../../library.html#joy.library.sharing">[docs]</a><span class="nd">@inscribe</span>
 758 <span class="nd">@FunctionWrapper</span>
 759 <span class="k">def</span> <span class="nf">sharing</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 760         <span class="sd">&#39;&#39;&#39;Print redistribution information.&#39;&#39;&#39;</span>
 761         <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;You may convey verbatim copies of the Program&#39;s source code as&quot;</span>
 762         <span class="s1">&#39; you receive it, in any medium, provided that you conspicuously&#39;</span>
 763         <span class="s1">&#39; and appropriately publish on each copy an appropriate copyright&#39;</span>
 764         <span class="s1">&#39; notice; keep intact all notices stating that this License and&#39;</span>
 765         <span class="s1">&#39; any non-permissive terms added in accord with section 7 apply&#39;</span>
 766         <span class="s1">&#39; to the code; keep intact all notices of the absence of any&#39;</span>
 767         <span class="s1">&#39; warranty; and give all recipients a copy of this License along&#39;</span>
 768         <span class="s1">&#39; with the Program.&#39;</span>
 769         <span class="s1">&#39; You should have received a copy of the GNU General Public License&#39;</span>
 770         <span class="s1">&#39; along with Thun.  If not see &lt;http://www.gnu.org/licenses/&gt;.&#39;</span><span class="p">)</span>
 771         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 772
 773
 774 <div class="viewcode-block" id="warranty"><a class="viewcode-back" href="../../library.html#joy.library.warranty">[docs]</a><span class="nd">@inscribe</span>
 775 <span class="nd">@FunctionWrapper</span>
 776 <span class="k">def</span> <span class="nf">warranty</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 777         <span class="sd">&#39;&#39;&#39;Print warranty information.&#39;&#39;&#39;</span>
 778         <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY&#39;</span>
 779         <span class="s1">&#39; APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE&#39;</span>
 780         <span class="s1">&#39; COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM&#39;</span>
 781         <span class="s1">&#39; &quot;AS IS&quot; WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR&#39;</span>
 782         <span class="s1">&#39; IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES&#39;</span>
 783         <span class="s1">&#39; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE&#39;</span>
 784         <span class="s1">&#39; ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS&#39;</span>
 785         <span class="s1">&#39; WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE&#39;</span>
 786         <span class="s1">&#39; COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.&#39;</span><span class="p">)</span>
 787         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 788
 789
 790 <span class="c1"># def simple_manual(stack):</span>
 791 <span class="c1">#   &#39;&#39;&#39;</span>
 792 <span class="c1">#   Print words and help for each word.</span>
 793 <span class="c1">#   &#39;&#39;&#39;</span>
 794 <span class="c1">#   for name, f in sorted(FUNCTIONS.items()):</span>
 795 <span class="c1">#     d = getdoc(f)</span>
 796 <span class="c1">#     boxline = &#39;+%s+&#39; % (&#39;-&#39; * (len(name) + 2))</span>
 797 <span class="c1">#     print(&#39;\n&#39;.join((</span>
 798 <span class="c1">#       boxline,</span>
 799 <span class="c1">#       &#39;| %s |&#39; % (name,),</span>
 800 <span class="c1">#       boxline,</span>
 801 <span class="c1">#       d if d else &#39;   ...&#39;,</span>
 802 <span class="c1">#       &#39;&#39;,</span>
 803 <span class="c1">#       &#39;--&#39; * 40,</span>
 804 <span class="c1">#       &#39;&#39;,</span>
 805 <span class="c1">#       )))</span>
 806 <span class="c1">#   return stack</span>
 807
 808
 809 <div class="viewcode-block" id="help_"><a class="viewcode-back" href="../../library.html#joy.library.help_">[docs]</a><span class="nd">@inscribe</span>
 810 <span class="nd">@FunctionWrapper</span>
 811 <span class="k">def</span> <span class="nf">help_</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 812         <span class="sd">&#39;&#39;&#39;Accepts a quoted symbol on the top of the stack and prints its docs.&#39;&#39;&#39;</span>
 813         <span class="p">((</span><span class="n">symbol</span><span class="p">,</span> <span class="n">_</span><span class="p">),</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">S</span>
 814         <span class="n">word</span> <span class="o">=</span> <span class="n">dictionary</span><span class="p">[</span><span class="n">symbol</span><span class="p">]</span>
 815         <span class="nb">print</span><span class="p">(</span><span class="n">HELP_TEMPLATE</span> <span class="o">%</span> <span class="p">(</span><span class="n">symbol</span><span class="p">,</span> <span class="n">getdoc</span><span class="p">(</span><span class="n">word</span><span class="p">),</span> <span class="n">symbol</span><span class="p">))</span>
 816         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
 817
 818
 819 <span class="c1">#</span>
 820 <span class="c1"># § Combinators</span>
 821 <span class="c1">#</span>
 822
 823
 824 <span class="c1"># Several combinators depend on other words in their definitions,</span>
 825 <span class="c1"># we use symbols to prevent hard-coding these, so in theory, you</span>
 826 <span class="c1"># could change the word in the dictionary to use different semantics.</span>
 827 <span class="n">S_choice</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;choice&#39;</span><span class="p">)</span>
 828 <span class="n">S_first</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;first&#39;</span><span class="p">)</span>
 829 <span class="n">S_genrec</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;genrec&#39;</span><span class="p">)</span>
 830 <span class="n">S_getitem</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;getitem&#39;</span><span class="p">)</span>
 831 <span class="n">S_i</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;i&#39;</span><span class="p">)</span>
 832 <span class="n">S_ifte</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;ifte&#39;</span><span class="p">)</span>
 833 <span class="n">S_infra</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;infra&#39;</span><span class="p">)</span>
 834 <span class="n">S_loop</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;loop&#39;</span><span class="p">)</span>
 835 <span class="n">S_pop</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;pop&#39;</span><span class="p">)</span>
 836 <span class="n">S_primrec</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;primrec&#39;</span><span class="p">)</span>
 837 <span class="n">S_step</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;step&#39;</span><span class="p">)</span>
 838 <span class="n">S_swaack</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;swaack&#39;</span><span class="p">)</span>
 839 <span class="n">S_times</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;times&#39;</span><span class="p">)</span>
 840
 841
 842 <div class="viewcode-block" id="i"><a class="viewcode-back" href="../../library.html#joy.library.i">[docs]</a><span class="nd">@inscribe</span>
 843 <span class="nd">@FunctionWrapper</span>
 844 <span class="k">def</span> <span class="nf">i</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 845         <span class="sd">&#39;&#39;&#39;</span>
 846 <span class="sd">       The i combinator expects a quoted program on the stack and unpacks it</span>
 847 <span class="sd">       onto the pending expression for evaluation.</span>
 848 <span class="sd">       ::</span>
 849
 850 <span class="sd">                  [Q] i</span>
 851 <span class="sd">               -----------</span>
 852 <span class="sd">                   Q</span>
 853
 854 <span class="sd">       &#39;&#39;&#39;</span>
 855         <span class="n">quote</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
 856         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
 857
 858
 859 <div class="viewcode-block" id="x"><a class="viewcode-back" href="../../library.html#joy.library.x">[docs]</a><span class="nd">@inscribe</span>
 860 <span class="nd">@FunctionWrapper</span>
 861 <span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 862         <span class="sd">&#39;&#39;&#39;</span>
 863 <span class="sd">       ::</span>
 864
 865 <span class="sd">               x == dup i</span>
 866
 867 <span class="sd">               ... [Q] x = ... [Q] dup i</span>
 868 <span class="sd">               ... [Q] x = ... [Q] [Q] i</span>
 869 <span class="sd">               ... [Q] x = ... [Q]  Q</span>
 870
 871 <span class="sd">       &#39;&#39;&#39;</span>
 872         <span class="n">quote</span><span class="p">,</span> <span class="n">_</span> <span class="o">=</span> <span class="n">stack</span>
 873         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
 874
 875
 876 <div class="viewcode-block" id="b"><a class="viewcode-back" href="../../library.html#joy.library.b">[docs]</a><span class="nd">@inscribe</span>
 877 <span class="nd">@FunctionWrapper</span>
 878 <span class="k">def</span> <span class="nf">b</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 879         <span class="sd">&#39;&#39;&#39;</span>
 880 <span class="sd">       ::</span>
 881
 882 <span class="sd">               b == [i] dip i</span>
 883
 884 <span class="sd">               ... [P] [Q] b == ... [P] i [Q] i</span>
 885 <span class="sd">               ... [P] [Q] b == ... P Q</span>
 886
 887 <span class="sd">       &#39;&#39;&#39;</span>
 888         <span class="n">q</span><span class="p">,</span> <span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="p">(</span><span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 889         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">expression</span><span class="p">)),</span> <span class="n">dictionary</span></div>
 890
 891
 892 <div class="viewcode-block" id="dupdip"><a class="viewcode-back" href="../../library.html#joy.library.dupdip">[docs]</a><span class="nd">@inscribe</span>
 893 <span class="nd">@FunctionWrapper</span>
 894 <span class="k">def</span> <span class="nf">dupdip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 895         <span class="sd">&#39;&#39;&#39;</span>
 896 <span class="sd">       ::</span>
 897
 898 <span class="sd">               [F] dupdip == dup [F] dip</span>
 899
 900 <span class="sd">               ... a [F] dupdip</span>
 901 <span class="sd">               ... a dup [F] dip</span>
 902 <span class="sd">               ... a a   [F] dip</span>
 903 <span class="sd">               ... a F a</span>
 904
 905 <span class="sd">       &#39;&#39;&#39;</span>
 906         <span class="n">F</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
 907         <span class="n">a</span> <span class="o">=</span> <span class="n">stack</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
 908         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">F</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span>  <span class="n">expression</span><span class="p">)),</span> <span class="n">dictionary</span></div>
 909
 910
 911 <div class="viewcode-block" id="infra"><a class="viewcode-back" href="../../library.html#joy.library.infra">[docs]</a><span class="nd">@inscribe</span>
 912 <span class="nd">@FunctionWrapper</span>
 913 <span class="k">def</span> <span class="nf">infra</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 914         <span class="sd">&#39;&#39;&#39;</span>
 915 <span class="sd">       Accept a quoted program and a list on the stack and run the program</span>
 916 <span class="sd">       with the list as its stack.  Does not affect the rest of the stack.</span>
 917 <span class="sd">       ::</span>
 918
 919 <span class="sd">                  ... [a b c] [Q] . infra</span>
 920 <span class="sd">               -----------------------------</span>
 921 <span class="sd">                   c b a . Q [...] swaack</span>
 922
 923 <span class="sd">       &#39;&#39;&#39;</span>
 924         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">aggregate</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 925         <span class="k">return</span> <span class="n">aggregate</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="p">(</span><span class="n">S_swaack</span><span class="p">,</span> <span class="n">expression</span><span class="p">))),</span> <span class="n">dictionary</span></div>
 926
 927
 928 <div class="viewcode-block" id="genrec"><a class="viewcode-back" href="../../library.html#joy.library.genrec">[docs]</a><span class="nd">@inscribe</span>
 929 <span class="nd">@FunctionWrapper</span>
 930 <span class="k">def</span> <span class="nf">genrec</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 931         <span class="sd">&#39;&#39;&#39;</span>
 932 <span class="sd">       General Recursion Combinator.</span>
 933 <span class="sd">       ::</span>
 934
 935 <span class="sd">                                 [if] [then] [rec1] [rec2] genrec</span>
 936 <span class="sd">           ---------------------------------------------------------------------</span>
 937 <span class="sd">              [if] [then] [rec1 [[if] [then] [rec1] [rec2] genrec] rec2] ifte</span>
 938
 939 <span class="sd">       From &quot;Recursion Theory and Joy&quot; (j05cmp.html) by Manfred von Thun:</span>
 940 <span class="sd">       &quot;The genrec combinator takes four program parameters in addition to</span>
 941 <span class="sd">       whatever data parameters it needs. Fourth from the top is an if-part,</span>
 942 <span class="sd">       followed by a then-part. If the if-part yields true, then the then-part</span>
 943 <span class="sd">       is executed and the combinator terminates. The other two parameters are</span>
 944 <span class="sd">       the rec1-part and the rec2-part. If the if-part yields false, the</span>
 945 <span class="sd">       rec1-part is executed. Following that the four program parameters and</span>
 946 <span class="sd">       the combinator are again pushed onto the stack bundled up in a quoted</span>
 947 <span class="sd">       form. Then the rec2-part is executed, where it will find the bundled</span>
 948 <span class="sd">       form. Typically it will then execute the bundled form, either with i or</span>
 949 <span class="sd">       with app2, or some other combinator.&quot;</span>
 950
 951 <span class="sd">       The way to design one of these is to fix your base case [then] and the</span>
 952 <span class="sd">       test [if], and then treat rec1 and rec2 as an else-part &quot;sandwiching&quot;</span>
 953 <span class="sd">       a quotation of the whole function.</span>
 954
 955 <span class="sd">       For example, given a (general recursive) function &#39;F&#39;:</span>
 956 <span class="sd">       ::</span>
 957
 958 <span class="sd">               F == [I] [T] [R1] [R2] genrec</span>
 959
 960 <span class="sd">       If the [I] if-part fails you must derive R1 and R2 from:</span>
 961 <span class="sd">       ::</span>
 962
 963 <span class="sd">               ... R1 [F] R2</span>
 964
 965 <span class="sd">       Just set the stack arguments in front, and figure out what R1 and R2</span>
 966 <span class="sd">       have to do to apply the quoted [F] in the proper way.  In effect, the</span>
 967 <span class="sd">       genrec combinator turns into an ifte combinator with a quoted copy of</span>
 968 <span class="sd">       the original definition in the else-part:</span>
 969 <span class="sd">       ::</span>
 970
 971 <span class="sd">               F == [I] [T] [R1]   [R2] genrec</span>
 972 <span class="sd">                 == [I] [T] [R1 [F] R2] ifte</span>
 973
 974 <span class="sd">       Primitive recursive functions are those where R2 == i.</span>
 975 <span class="sd">       ::</span>
 976
 977 <span class="sd">               P == [I] [T] [R] tailrec</span>
 978 <span class="sd">                 == [I] [T] [R [P] i] ifte</span>
 979 <span class="sd">                 == [I] [T] [R P] ifte</span>
 980
 981 <span class="sd">       &#39;&#39;&#39;</span>
 982         <span class="p">(</span><span class="n">rec2</span><span class="p">,</span> <span class="p">(</span><span class="n">rec1</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 983         <span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">if_</span><span class="p">,</span> <span class="n">_</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 984         <span class="n">F</span> <span class="o">=</span> <span class="p">(</span><span class="n">if_</span><span class="p">,</span> <span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">rec1</span><span class="p">,</span> <span class="p">(</span><span class="n">rec2</span><span class="p">,</span> <span class="p">(</span><span class="n">S_genrec</span><span class="p">,</span> <span class="p">())))))</span>
 985         <span class="n">else_</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">rec1</span><span class="p">,</span> <span class="p">(</span><span class="n">F</span><span class="p">,</span> <span class="n">rec2</span><span class="p">))</span>
 986         <span class="k">return</span> <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="p">(</span><span class="n">S_ifte</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
 987
 988
 989 <div class="viewcode-block" id="map_"><a class="viewcode-back" href="../../library.html#joy.library.map_">[docs]</a><span class="nd">@inscribe</span>
 990 <span class="nd">@FunctionWrapper</span>
 991 <span class="k">def</span> <span class="nf">map_</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 992         <span class="sd">&#39;&#39;&#39;</span>
 993 <span class="sd">       Run the quoted program on TOS on the items in the list under it, push a</span>
 994 <span class="sd">       new list with the results in place of the program and original list.</span>
 995 <span class="sd">       &#39;&#39;&#39;</span>
 996         <span class="c1"># (quote, (aggregate, stack)) = S</span>
 997         <span class="c1"># results = list_to_stack([</span>
 998         <span class="c1"># joy((term, stack), quote, dictionary)[0][0]</span>
 999         <span class="c1"># for term in iter_stack(aggregate)</span>
1000         <span class="c1"># ])</span>
1001         <span class="c1"># return (results, stack), expression, dictionary</span>
1002         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">aggregate</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
1003         <span class="k">if</span> <span class="ow">not</span> <span class="n">aggregate</span><span class="p">:</span>
1004                 <span class="k">return</span> <span class="p">(</span><span class="n">aggregate</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
1005         <span class="n">batch</span> <span class="o">=</span> <span class="p">()</span>
1006         <span class="k">for</span> <span class="n">term</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">aggregate</span><span class="p">):</span>
1007                 <span class="n">s</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">stack</span>
1008                 <span class="n">batch</span> <span class="o">=</span> <span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span> <span class="n">batch</span><span class="p">))))</span>
1009         <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">batch</span><span class="p">,</span> <span class="p">((),</span> <span class="n">stack</span><span class="p">))</span>
1010         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
1011
1012
1013 <div class="viewcode-block" id="primrec"><a class="viewcode-back" href="../../library.html#joy.library.primrec">[docs]</a><span class="nd">@inscribe</span>
1014 <span class="nd">@FunctionWrapper</span>
1015 <span class="k">def</span> <span class="nf">primrec</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1016         <span class="sd">&#39;&#39;&#39;</span>
1017 <span class="sd">       From the &quot;Overview of the language JOY&quot;:</span>
1018
1019 <span class="sd">       &gt; The primrec combinator expects two quoted programs in addition to a</span>
1020 <span class="sd">       data parameter. For an integer data parameter it works like this: If</span>
1021 <span class="sd">       the data parameter is zero, then the first quotation has to produce</span>
1022 <span class="sd">       the value to be returned. If the data parameter is positive then the</span>
1023 <span class="sd">       second has to combine the data parameter with the result of applying</span>
1024 <span class="sd">       the function to its predecessor.::</span>
1025
1026 <span class="sd">               5  [1]  [*]  primrec</span>
1027
1028 <span class="sd">       &gt; Then primrec tests whether the top element on the stack (initially</span>
1029 <span class="sd">       the 5) is equal to zero. If it is, it pops it off and executes one of</span>
1030 <span class="sd">       the quotations, the [1] which leaves 1 on the stack as the result.</span>
1031 <span class="sd">       Otherwise it pushes a decremented copy of the top element and</span>
1032 <span class="sd">       recurses. On the way back from the recursion it uses the other</span>
1033 <span class="sd">       quotation, [*], to multiply what is now a factorial on top of the</span>
1034 <span class="sd">       stack by the second element on the stack.::</span>
1035
1036 <span class="sd">               n [Base] [Recur] primrec</span>
1037
1038 <span class="sd">                  0 [Base] [Recur] primrec</span>
1039 <span class="sd">               ------------------------------</span>
1040 <span class="sd">                     Base</span>
1041
1042 <span class="sd">                        n [Base] [Recur] primrec</span>
1043 <span class="sd">               ------------------------------------------ n &gt; 0</span>
1044 <span class="sd">                  n (n-1) [Base] [Recur] primrec Recur</span>
1045
1046 <span class="sd">       &#39;&#39;&#39;</span>
1047         <span class="n">recur</span><span class="p">,</span> <span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
1048         <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span>
1049                 <span class="n">expression</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1050         <span class="k">else</span><span class="p">:</span>
1051                 <span class="n">expression</span> <span class="o">=</span> <span class="n">S_primrec</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">recur</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1052                 <span class="n">stack</span> <span class="o">=</span> <span class="n">recur</span><span class="p">,</span> <span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span>
1053         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1054
1055
1056 <span class="c1">#def cleave(S, expression, dictionary):</span>
1057 <span class="c1">#  &#39;&#39;&#39;</span>
1058 <span class="c1">#  The cleave combinator expects two quotations, and below that an item X.</span>
1059 <span class="c1">#  It first executes [P], with X on top, and saves the top result element.</span>
1060 <span class="c1">#  Then it executes [Q], again with X, and saves the top result.</span>
1061 <span class="c1">#  Finally it restores the stack to what it was below X and pushes the two</span>
1062 <span class="c1">#  results P(X) and Q(X).</span>
1063 <span class="c1">#  &#39;&#39;&#39;</span>
1064 <span class="c1">#  (Q, (P, (x, stack))) = S</span>
1065 <span class="c1">#  p = joy((x, stack), P, dictionary)[0][0]</span>
1066 <span class="c1">#  q = joy((x, stack), Q, dictionary)[0][0]</span>
1067 <span class="c1">#  return (q, (p, stack)), expression, dictionary</span>
1068
1069
1070 <div class="viewcode-block" id="branch"><a class="viewcode-back" href="../../library.html#joy.library.branch">[docs]</a><span class="nd">@inscribe</span>
1071 <span class="nd">@FunctionWrapper</span>
1072 <span class="k">def</span> <span class="nf">branch</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1073         <span class="sd">&#39;&#39;&#39;</span>
1074 <span class="sd">       Use a Boolean value to select one of two quoted programs to run.</span>
1075
1076 <span class="sd">       ::</span>
1077
1078 <span class="sd">               branch == roll&lt; choice i</span>
1079
1080 <span class="sd">       ::</span>
1081
1082 <span class="sd">                  False [F] [T] branch</span>
1083 <span class="sd">               --------------------------</span>
1084 <span class="sd">                         F</span>
1085
1086 <span class="sd">                  True [F] [T] branch</span>
1087 <span class="sd">               -------------------------</span>
1088 <span class="sd">                            T</span>
1089
1090 <span class="sd">       &#39;&#39;&#39;</span>
1091         <span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">stack</span>
1092         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">then</span> <span class="k">if</span> <span class="n">flag</span> <span class="k">else</span> <span class="n">else_</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
1093
1094
1095 <span class="c1">##@inscribe</span>
1096 <span class="c1">##@FunctionWrapper</span>
1097 <span class="c1">##def ifte(stack, expression, dictionary):</span>
1098 <span class="c1">##  &#39;&#39;&#39;</span>
1099 <span class="c1">##  If-Then-Else Combinator</span>
1100 <span class="c1">##  ::</span>
1101 <span class="c1">##</span>
1102 <span class="c1">##                  ... [if] [then] [else] ifte</span>
1103 <span class="c1">##       ---------------------------------------------------</span>
1104 <span class="c1">##          ... [[else] [then]] [...] [if] infra select i</span>
1105 <span class="c1">##</span>
1106 <span class="c1">##</span>
1107 <span class="c1">##</span>
1108 <span class="c1">##</span>
1109 <span class="c1">##                ... [if] [then] [else] ifte</span>
1110 <span class="c1">##       -------------------------------------------------------</span>
1111 <span class="c1">##          ... [else] [then] [...] [if] infra first choice i</span>
1112 <span class="c1">##</span>
1113 <span class="c1">##</span>
1114 <span class="c1">##  Has the effect of grabbing a copy of the stack on which to run the</span>
1115 <span class="c1">##  if-part using infra.</span>
1116 <span class="c1">##  &#39;&#39;&#39;</span>
1117 <span class="c1">##  (else_, (then, (if_, stack))) = stack</span>
1118 <span class="c1">##  expression = (S_infra, (S_first, (S_choice, (S_i, expression))))</span>
1119 <span class="c1">##  stack = (if_, (stack, (then, (else_, stack))))</span>
1120 <span class="c1">##  return stack, expression, dictionary</span>
1121
1122
1123 <div class="viewcode-block" id="cond"><a class="viewcode-back" href="../../library.html#joy.library.cond">[docs]</a><span class="nd">@inscribe</span>
1124 <span class="nd">@FunctionWrapper</span>
1125 <span class="k">def</span> <span class="nf">cond</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1126         <span class="sd">&#39;&#39;&#39;</span>
1127 <span class="sd">       This combinator works like a case statement.  It expects a single quote</span>
1128 <span class="sd">       on the stack that must contain zero or more condition quotes and a </span>
1129 <span class="sd">       default quote.  Each condition clause should contain a quoted predicate</span>
1130 <span class="sd">       followed by the function expression to run if that predicate returns</span>
1131 <span class="sd">       true.  If no predicates return true the default function runs.</span>
1132
1133 <span class="sd">       It works by rewriting into a chain of nested `ifte` expressions, e.g.::</span>
1134
1135 <span class="sd">                     [[[B0] T0] [[B1] T1] [D]] cond</span>
1136 <span class="sd">               -----------------------------------------</span>
1137 <span class="sd">                  [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
1138
1139 <span class="sd">       &#39;&#39;&#39;</span>
1140         <span class="n">conditions</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
1141         <span class="k">if</span> <span class="n">conditions</span><span class="p">:</span>
1142                 <span class="n">expression</span> <span class="o">=</span> <span class="n">_cond</span><span class="p">(</span><span class="n">conditions</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1143                 <span class="k">try</span><span class="p">:</span>
1144                         <span class="c1"># Attempt to preload the args to first ifte.</span>
1145                         <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span> <span class="o">=</span> <span class="n">expression</span>
1146                 <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
1147                         <span class="c1"># If, for any reason, the argument to cond should happen to contain</span>
1148                         <span class="c1"># only the default clause then this optimization will fail.</span>
1149                         <span class="k">pass</span>
1150                 <span class="k">else</span><span class="p">:</span>
1151                         <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span>
1152         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1153
1154
1155 <span class="k">def</span> <span class="nf">_cond</span><span class="p">(</span><span class="n">conditions</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
1156         <span class="p">(</span><span class="n">clause</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span> <span class="o">=</span> <span class="n">conditions</span>
1157         <span class="k">if</span> <span class="ow">not</span> <span class="n">rest</span><span class="p">:</span>  <span class="c1"># clause is [D]</span>
1158                 <span class="k">return</span> <span class="n">clause</span>
1159         <span class="n">P</span><span class="p">,</span> <span class="n">T</span> <span class="o">=</span> <span class="n">clause</span>
1160         <span class="k">return</span> <span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="p">(</span><span class="n">T</span><span class="p">,</span> <span class="p">(</span><span class="n">_cond</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="p">()),</span> <span class="p">(</span><span class="n">S_ifte</span><span class="p">,</span> <span class="n">expression</span><span class="p">))))</span>
1161
1162
1163 <div class="viewcode-block" id="dip"><a class="viewcode-back" href="../../library.html#joy.library.dip">[docs]</a><span class="nd">@inscribe</span>
1164 <span class="nd">@FunctionWrapper</span>
1165 <span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1166         <span class="sd">&#39;&#39;&#39;</span>
1167 <span class="sd">       The dip combinator expects a quoted program on the stack and below it</span>
1168 <span class="sd">       some item, it hoists the item into the expression and runs the program</span>
1169 <span class="sd">       on the rest of the stack.</span>
1170 <span class="sd">       ::</span>
1171
1172 <span class="sd">                  ... x [Q] dip</span>
1173 <span class="sd">               -------------------</span>
1174 <span class="sd">                    ... Q x</span>
1175
1176 <span class="sd">       &#39;&#39;&#39;</span>
1177         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
1178         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1179         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
1180
1181
1182 <div class="viewcode-block" id="dipd"><a class="viewcode-back" href="../../library.html#joy.library.dipd">[docs]</a><span class="nd">@inscribe</span>
1183 <span class="nd">@FunctionWrapper</span>
1184 <span class="k">def</span> <span class="nf">dipd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1185         <span class="sd">&#39;&#39;&#39;</span>
1186 <span class="sd">       Like dip but expects two items.</span>
1187 <span class="sd">       ::</span>
1188
1189 <span class="sd">                  ... y x [Q] dip</span>
1190 <span class="sd">               ---------------------</span>
1191 <span class="sd">                    ... Q y x</span>
1192
1193 <span class="sd">       &#39;&#39;&#39;</span>
1194         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">S</span>
1195         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span>
1196         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
1197
1198
1199 <div class="viewcode-block" id="dipdd"><a class="viewcode-back" href="../../library.html#joy.library.dipdd">[docs]</a><span class="nd">@inscribe</span>
1200 <span class="nd">@FunctionWrapper</span>
1201 <span class="k">def</span> <span class="nf">dipdd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1202         <span class="sd">&#39;&#39;&#39;</span>
1203 <span class="sd">       Like dip but expects three items.</span>
1204 <span class="sd">       ::</span>
1205
1206 <span class="sd">                  ... z y x [Q] dip</span>
1207 <span class="sd">               -----------------------</span>
1208 <span class="sd">                    ... Q z y x</span>
1209
1210 <span class="sd">       &#39;&#39;&#39;</span>
1211         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">S</span>
1212         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
1213         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
1214
1215
1216 <div class="viewcode-block" id="app1"><a class="viewcode-back" href="../../library.html#joy.library.app1">[docs]</a><span class="nd">@inscribe</span>
1217 <span class="nd">@FunctionWrapper</span>
1218 <span class="k">def</span> <span class="nf">app1</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1219         <span class="sd">&#39;&#39;&#39;</span>
1220 <span class="sd">       Given a quoted program on TOS and anything as the second stack item run</span>
1221 <span class="sd">       the program and replace the two args with the first result of the</span>
1222 <span class="sd">       program.</span>
1223 <span class="sd">       ::</span>
1224
1225 <span class="sd">                        ... x [Q] . app1</span>
1226 <span class="sd">               -----------------------------------</span>
1227 <span class="sd">                  ... [x ...] [Q] . infra first</span>
1228
1229 <span class="sd">       &#39;&#39;&#39;</span>
1230         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
1231         <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">stack</span><span class="p">))</span>
1232         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span>
1233         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1234
1235
1236 <div class="viewcode-block" id="app2"><a class="viewcode-back" href="../../library.html#joy.library.app2">[docs]</a><span class="nd">@inscribe</span>
1237 <span class="nd">@FunctionWrapper</span>
1238 <span class="k">def</span> <span class="nf">app2</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1239         <span class="sd">&#39;&#39;&#39;Like app1 with two items.</span>
1240 <span class="sd">       ::</span>
1241
1242 <span class="sd">                      ... y x [Q] . app2</span>
1243 <span class="sd">               -----------------------------------</span>
1244 <span class="sd">                  ... [y ...] [Q] . infra first</span>
1245 <span class="sd">                      [x ...] [Q]   infra first</span>
1246
1247 <span class="sd">       &#39;&#39;&#39;</span>
1248         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">S</span>
1249         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span>
1250                 <span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span>
1251                         <span class="n">expression</span><span class="p">))))))</span>
1252         <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">((</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">stack</span><span class="p">))</span>
1253         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1254
1255
1256 <div class="viewcode-block" id="app3"><a class="viewcode-back" href="../../library.html#joy.library.app3">[docs]</a><span class="nd">@inscribe</span>
1257 <span class="nd">@FunctionWrapper</span>
1258 <span class="k">def</span> <span class="nf">app3</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1259         <span class="sd">&#39;&#39;&#39;Like app1 with three items.</span>
1260 <span class="sd">       ::</span>
1261
1262 <span class="sd">                    ... z y x [Q] . app3</span>
1263 <span class="sd">               -----------------------------------</span>
1264 <span class="sd">                  ... [z ...] [Q] . infra first</span>
1265 <span class="sd">                      [y ...] [Q]   infra first</span>
1266 <span class="sd">                      [x ...] [Q]   infra first</span>
1267
1268 <span class="sd">       &#39;&#39;&#39;</span>
1269         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">S</span>
1270         <span class="n">expression</span> <span class="o">=</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span>
1271                 <span class="p">((</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span>
1272                 <span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_infra</span><span class="p">,</span> <span class="p">(</span><span class="n">S_first</span><span class="p">,</span>
1273                         <span class="n">expression</span><span class="p">))))))))))</span>
1274         <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">((</span><span class="n">z</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">stack</span><span class="p">))</span>
1275         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1276
1277
1278 <div class="viewcode-block" id="step"><a class="viewcode-back" href="../../library.html#joy.library.step">[docs]</a><span class="nd">@inscribe</span>
1279 <span class="nd">@FunctionWrapper</span>
1280 <span class="k">def</span> <span class="nf">step</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1281         <span class="sd">&#39;&#39;&#39;</span>
1282 <span class="sd">       Run a quoted program on each item in a sequence.</span>
1283 <span class="sd">       ::</span>
1284
1285 <span class="sd">                  ... [] [Q] . step</span>
1286 <span class="sd">               -----------------------</span>
1287 <span class="sd">                         ... .</span>
1288
1289
1290 <span class="sd">                  ... [a] [Q] . step</span>
1291 <span class="sd">               ------------------------</span>
1292 <span class="sd">                        ... a . Q</span>
1293
1294
1295 <span class="sd">                  ... [a b c] [Q] . step</span>
1296 <span class="sd">               ----------------------------------------</span>
1297 <span class="sd">                            ... a . Q [b c] [Q] step</span>
1298
1299 <span class="sd">       The step combinator executes the quotation on each member of the list</span>
1300 <span class="sd">       on top of the stack.</span>
1301 <span class="sd">       &#39;&#39;&#39;</span>
1302         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">aggregate</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
1303         <span class="k">if</span> <span class="ow">not</span> <span class="n">aggregate</span><span class="p">:</span>
1304                 <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
1305         <span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">aggregate</span>
1306         <span class="n">stack</span> <span class="o">=</span> <span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span>
1307         <span class="k">if</span> <span class="n">tail</span><span class="p">:</span>
1308                 <span class="n">expression</span> <span class="o">=</span> <span class="n">tail</span><span class="p">,</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_step</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span>
1309         <span class="n">expression</span> <span class="o">=</span> <span class="n">S_i</span><span class="p">,</span> <span class="n">expression</span>
1310         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1311
1312
1313 <div class="viewcode-block" id="times"><a class="viewcode-back" href="../../library.html#joy.library.times">[docs]</a><span class="nd">@inscribe</span>
1314 <span class="nd">@FunctionWrapper</span>
1315 <span class="k">def</span> <span class="nf">times</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1316         <span class="sd">&#39;&#39;&#39;</span>
1317 <span class="sd">       times == [-- dip] cons [swap] infra [0 &gt;] swap while pop</span>
1318 <span class="sd">       ::</span>
1319
1320 <span class="sd">                  ... n [Q] . times</span>
1321 <span class="sd">               ---------------------  w/ n &lt;= 0</span>
1322 <span class="sd">                        ... .</span>
1323
1324
1325 <span class="sd">                  ... 1 [Q] . times</span>
1326 <span class="sd">               -----------------------</span>
1327 <span class="sd">                        ... . Q</span>
1328
1329
1330 <span class="sd">                  ... n [Q] . times</span>
1331 <span class="sd">               -------------------------------------  w/ n &gt; 1</span>
1332 <span class="sd">                        ... . Q (n - 1) [Q] times</span>
1333
1334 <span class="sd">       &#39;&#39;&#39;</span>
1335         <span class="c1"># times == [-- dip] cons [swap] infra [0 &gt;] swap while pop</span>
1336         <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
1337         <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">0</span><span class="p">:</span>
1338                 <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
1339         <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
1340         <span class="k">if</span> <span class="n">n</span><span class="p">:</span>
1341                 <span class="n">expression</span> <span class="o">=</span> <span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_times</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span>
1342         <span class="n">expression</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1343         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1344
1345
1346 <span class="c1"># The current definition above works like this:</span>
1347
1348 <span class="c1">#             [P] [Q] while</span>
1349 <span class="c1"># --------------------------------------</span>
1350 <span class="c1">#    [P] nullary [Q [P] nullary] loop</span>
1351
1352 <span class="c1">#   while == [pop i not] [popop] [dudipd] tailrec</span>
1353
1354 <span class="c1">#def while_(S, expression, dictionary):</span>
1355 <span class="c1">#  &#39;&#39;&#39;[if] [body] while&#39;&#39;&#39;</span>
1356 <span class="c1">#  (body, (if_, stack)) = S</span>
1357 <span class="c1">#  while joy(stack, if_, dictionary)[0][0]:</span>
1358 <span class="c1">#    stack = joy(stack, body, dictionary)[0]</span>
1359 <span class="c1">#  return stack, expression, dictionary</span>
1360
1361
1362 <div class="viewcode-block" id="loop"><a class="viewcode-back" href="../../library.html#joy.library.loop">[docs]</a><span class="nd">@inscribe</span>
1363 <span class="nd">@FunctionWrapper</span>
1364 <span class="k">def</span> <span class="nf">loop</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1365         <span class="sd">&#39;&#39;&#39;</span>
1366 <span class="sd">       Basic loop combinator.</span>
1367 <span class="sd">       ::</span>
1368
1369 <span class="sd">                  ... True [Q] loop</span>
1370 <span class="sd">               -----------------------</span>
1371 <span class="sd">                     ... Q [Q] loop</span>
1372
1373 <span class="sd">                  ... False [Q] loop</span>
1374 <span class="sd">               ------------------------</span>
1375 <span class="sd">                         ...</span>
1376
1377 <span class="sd">       &#39;&#39;&#39;</span>
1378         <span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
1379         <span class="k">if</span> <span class="n">flag</span><span class="p">:</span>
1380                 <span class="n">expression</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_loop</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
1381         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1382
1383
1384 <div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
1385 <span class="nd">@FunctionWrapper</span>
1386 <span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
1387         <span class="sd">&#39;&#39;&#39;</span>
1388 <span class="sd">       cmp takes two values and three quoted programs on the stack and runs</span>
1389 <span class="sd">       one of the three depending on the results of comparing the two values:</span>
1390 <span class="sd">       ::</span>
1391
1392 <span class="sd">                  a b [G] [E] [L] cmp</span>
1393 <span class="sd">               ------------------------- a &gt; b</span>
1394 <span class="sd">                       G</span>
1395
1396 <span class="sd">                  a b [G] [E] [L] cmp</span>
1397 <span class="sd">               ------------------------- a = b</span>
1398 <span class="sd">                           E</span>
1399
1400 <span class="sd">                  a b [G] [E] [L] cmp</span>
1401 <span class="sd">               ------------------------- a &lt; b</span>
1402 <span class="sd">                               L</span>
1403 <span class="sd">       &#39;&#39;&#39;</span>
1404         <span class="n">L</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
1405         <span class="n">expression</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
1406         <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
1407
1408
1409 <span class="c1">#  FunctionWrapper(cleave),</span>
1410 <span class="c1">#  FunctionWrapper(while_),</span>
1411
1412
1413 <span class="k">for</span> <span class="n">F</span> <span class="ow">in</span> <span class="p">(</span>
1414
1415         <span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</span>
1416
1417         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">eq</span><span class="p">),</span>
1418         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">),</span>
1419         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">gt</span><span class="p">),</span>
1420         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">),</span>
1421         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lt</span><span class="p">),</span>
1422         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ne</span><span class="p">),</span>
1423
1424         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">xor</span><span class="p">),</span>
1425         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lshift</span><span class="p">),</span>
1426         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">rshift</span><span class="p">),</span>
1427
1428         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">and_</span><span class="p">),</span>
1429         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">or_</span><span class="p">),</span>
1430
1431         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">),</span>
1432         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">floordiv</span><span class="p">),</span>
1433         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mod</span><span class="p">),</span>
1434         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">),</span>
1435         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">pow</span><span class="p">),</span>
1436         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">),</span>
1437         <span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">truediv</span><span class="p">),</span>
1438
1439         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">),</span>
1440         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">),</span>
1441
1442         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">abs</span><span class="p">),</span>
1443         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">neg</span><span class="p">),</span>
1444         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">),</span>
1445
1446         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">floor</span><span class="p">),</span>
1447         <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">round</span><span class="p">),</span>
1448         <span class="p">):</span>
1449         <span class="n">inscribe</span><span class="p">(</span><span class="n">F</span><span class="p">)</span>
1450 <span class="k">del</span> <span class="n">F</span>  <span class="c1"># Otherwise Sphinx autodoc will pick it up.</span>
1451
1452
1453 <span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">primitive</span> <span class="ow">in</span> <span class="n">getmembers</span><span class="p">(</span><span class="n">genlib</span><span class="p">,</span> <span class="n">isfunction</span><span class="p">):</span>
1454         <span class="n">inscribe</span><span class="p">(</span><span class="n">SimpleFunctionWrapper</span><span class="p">(</span><span class="n">primitive</span><span class="p">))</span>
1455
1456
1457 <span class="n">add_aliases</span><span class="p">(</span><span class="n">_dictionary</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
1458
1459
1460 <span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="n">definitions</span><span class="p">,</span> <span class="n">_dictionary</span><span class="p">)</span>
1461 </pre></div>
1462
1463           </div>
1464         </div>
1465       </div>
1466       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
1467         <div class="sphinxsidebarwrapper"><div class="relations">
1468 <h3>Related Topics</h3>
1469 <ul>
1470   <li><a href="../../index.html">Documentation overview</a><ul>
1471   <li><a href="../index.html">Module code</a><ul>
1472   </ul></li>
1473   </ul></li>
1474 </ul>
1475 </div>
1476 <div id="searchbox" style="display: none" role="search">
1477   <h3>Quick search</h3>
1478     <div class="searchformwrapper">
1479     <form class="search" action="../../search.html" method="get">
1480       <input type="text" name="q" />
1481       <input type="submit" value="Go" />
1482       <input type="hidden" name="check_keywords" value="yes" />
1483       <input type="hidden" name="area" value="default" />
1484     </form>
1485     </div>
1486 </div>
1487 <script type="text/javascript">$('#searchbox').show(0);</script>
1488         </div>
1489       </div>
1490       <div class="clearer"></div>
1491     </div>
1492     <div class="footer" role="contentinfo">
1493 <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">
1494 <img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" />
1495 </a>
1496 <br />
1497 <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>.
1498       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.3.
1499     </div>
1500
1501   </body>
1502 </html>