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

Remove the types stuff et. al.

Browse Source
This commit is contained in:
Simon Forman
2020-05-19 13:01:37 -07:00
parent 95cd1e6cc6
commit 8bd0e7ce0e
163 changed files with 90 additions and 33382 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/sphinx_docs/_build/html/_modules/joy/library.html
+65 -325
View File
@@ -33,7 +33,7 @@
<h1>Source code for joy.library</h1><div class="highlight"><pre>
<span></span><span class="c1"># -*- coding: utf-8 -*-</span>
<span class="c1">#</span>
<span class="c1"># Copyright © 2014, 2015, 2017, 2018 Simon Forman</span>
<span class="c1"># Copyright © 2014-2020 Simon Forman</span>
<span class="c1">#</span>
<span class="c1"># This file is part of Thun</span>
<span class="c1">#</span>
@@ -56,12 +56,7 @@
<span class="sd">returns a dictionary of Joy functions suitable for use with the joy()</span>
<span class="sd">function.</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span><span class="p">,</span> <span class="nb">object</span><span class="p">,</span> <span class="nb">range</span><span class="p">,</span> <span class="nb">zip</span>
<span class="kn">from</span> <span class="nn">logging</span> <span class="k">import</span> <span class="n">getLogger</span>
<span class="n">_log</span> <span class="o">=</span> <span class="n">getLogger</span><span class="p">(</span><span class="vm">__name__</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Loading library.&#39;</span><span class="p">)</span>
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getdoc</span>
<span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span>
@@ -70,38 +65,13 @@
<span class="kn">import</span> <span class="nn">operator</span><span class="o">,</span> <span class="nn">math</span>
<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>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">list_to_stack</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">,</span> <span class="n">pick</span><span class="p">,</span> <span class="n">concat</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">major</span> <span class="o">&lt;</span> <span class="mi">3</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.utils.brutal_hackery</span> <span class="k">import</span> <span class="n">rename_code_object</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">rename_code_object</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">:</span> <span class="k">lambda</span> <span class="n">f</span><span class="p">:</span> <span class="n">f</span>
<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>
<span class="kn">from</span> <span class="nn">.utils.types</span> <span class="k">import</span> <span class="p">(</span>
<span class="n">compose</span><span class="p">,</span>
<span class="n">ef</span><span class="p">,</span>
<span class="n">stack_effect</span><span class="p">,</span>
<span class="n">AnyJoyType</span><span class="p">,</span>
<span class="n">AnyStarJoyType</span><span class="p">,</span>
<span class="n">BooleanJoyType</span><span class="p">,</span>
<span class="n">NumberJoyType</span><span class="p">,</span>
<span class="n">NumberStarJoyType</span><span class="p">,</span>
<span class="n">StackJoyType</span><span class="p">,</span>
<span class="n">StackStarJoyType</span><span class="p">,</span>
<span class="n">FloatJoyType</span><span class="p">,</span>
<span class="n">IntJoyType</span><span class="p">,</span>
<span class="n">SymbolJoyType</span><span class="p">,</span>
<span class="n">CombinatorJoyType</span><span class="p">,</span>
<span class="n">TextJoyType</span><span class="p">,</span>
<span class="n">_functions</span><span class="p">,</span>
<span class="n">FUNCTIONS</span><span class="p">,</span>
<span class="n">infer</span><span class="p">,</span>
<span class="n">infer_expression</span><span class="p">,</span>
<span class="n">JoyTypeError</span><span class="p">,</span>
<span class="n">combinator_effect</span><span class="p">,</span>
<span class="n">poly_combinator_effect</span><span class="p">,</span>
<span class="n">doc_from_stack_effect</span><span class="p">,</span>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="p">(</span>
<span class="n">concat</span><span class="p">,</span>
<span class="n">expression_to_string</span><span class="p">,</span>
<span class="n">iter_stack</span><span class="p">,</span>
<span class="n">list_to_stack</span><span class="p">,</span>
<span class="n">pick</span><span class="p">,</span>
<span class="p">)</span>
@@ -115,38 +85,6 @@
<span class="s1">&#39;&#39;&#39;</span>
<span class="n">_SYM_NUMS</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">c</span><span class="o">=</span><span class="n">count</span><span class="p">():</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">_COMB_NUMS</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">c</span><span class="o">=</span><span class="n">count</span><span class="p">():</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">_R</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>
<span class="n">A</span> <span class="o">=</span> <span class="n">a0</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a4</span><span class="p">,</span> <span class="n">a5</span><span class="p">,</span> <span class="n">a6</span><span class="p">,</span> <span class="n">a7</span><span class="p">,</span> <span class="n">a8</span><span class="p">,</span> <span class="n">a9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">AnyJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">B</span> <span class="o">=</span> <span class="n">b0</span><span class="p">,</span> <span class="n">b1</span><span class="p">,</span> <span class="n">b2</span><span class="p">,</span> <span class="n">b3</span><span class="p">,</span> <span class="n">b4</span><span class="p">,</span> <span class="n">b5</span><span class="p">,</span> <span class="n">b6</span><span class="p">,</span> <span class="n">b7</span><span class="p">,</span> <span class="n">b8</span><span class="p">,</span> <span class="n">b9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">BooleanJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">N</span> <span class="o">=</span> <span class="n">n0</span><span class="p">,</span> <span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">,</span> <span class="n">n3</span><span class="p">,</span> <span class="n">n4</span><span class="p">,</span> <span class="n">n5</span><span class="p">,</span> <span class="n">n6</span><span class="p">,</span> <span class="n">n7</span><span class="p">,</span> <span class="n">n8</span><span class="p">,</span> <span class="n">n9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">NumberJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">S</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">,</span> <span class="n">s3</span><span class="p">,</span> <span class="n">s4</span><span class="p">,</span> <span class="n">s5</span><span class="p">,</span> <span class="n">s6</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s8</span><span class="p">,</span> <span class="n">s9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">StackJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">F</span> <span class="o">=</span> <span class="n">f0</span><span class="p">,</span> <span class="n">f1</span><span class="p">,</span> <span class="n">f2</span><span class="p">,</span> <span class="n">f3</span><span class="p">,</span> <span class="n">f4</span><span class="p">,</span> <span class="n">f5</span><span class="p">,</span> <span class="n">f6</span><span class="p">,</span> <span class="n">f7</span><span class="p">,</span> <span class="n">f8</span><span class="p">,</span> <span class="n">f9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">FloatJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">I</span> <span class="o">=</span> <span class="n">i0</span><span class="p">,</span> <span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">,</span> <span class="n">i3</span><span class="p">,</span> <span class="n">i4</span><span class="p">,</span> <span class="n">i5</span><span class="p">,</span> <span class="n">i6</span><span class="p">,</span> <span class="n">i7</span><span class="p">,</span> <span class="n">i8</span><span class="p">,</span> <span class="n">i9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">IntJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">T</span> <span class="o">=</span> <span class="n">t0</span><span class="p">,</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">,</span> <span class="n">t3</span><span class="p">,</span> <span class="n">t4</span><span class="p">,</span> <span class="n">t5</span><span class="p">,</span> <span class="n">t6</span><span class="p">,</span> <span class="n">t7</span><span class="p">,</span> <span class="n">t8</span><span class="p">,</span> <span class="n">t9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">TextJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">_R</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">))</span>
<span class="n">As</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">AnyStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">Ns</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">NumberStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">Ss</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">StackStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="c1"># &quot;sec&quot;: stack effect comment, like in Forth.</span>
<span class="n">sec0</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">t1</span><span class="p">)()</span>
<span class="n">sec1</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">i1</span><span class="p">)(</span><span class="n">s1</span><span class="p">)</span>
<span class="n">sec2</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">i1</span><span class="p">)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">sec_binary_cmp</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">)(</span><span class="n">b1</span><span class="p">)</span>
<span class="n">sec_binary_ints</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">)(</span><span class="n">i3</span><span class="p">)</span>
<span class="n">sec_binary_logic</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">b1</span><span class="p">,</span> <span class="n">b2</span><span class="p">)(</span><span class="n">b3</span><span class="p">)</span>
<span class="n">sec_binary_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">)(</span><span class="n">n3</span><span class="p">)</span>
<span class="n">sec_unary_logic</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">a1</span><span class="p">)(</span><span class="n">b1</span><span class="p">)</span>
<span class="n">sec_unary_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">)(</span><span class="n">n2</span><span class="p">)</span>
<span class="n">sec_Ns_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">((</span><span class="n">Ns</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">s1</span><span class="p">),)(</span><span class="n">n0</span><span class="p">)</span>
<span class="c1"># This is the main dict we&#39;re building.</span>
<span class="n">_dictionary</span> <span class="o">=</span> <span class="p">{}</span>
@@ -168,7 +106,6 @@
<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>
<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>
<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>
<span class="p">(</span><span class="s1">&#39;floor&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;round&#39;</span><span class="p">]),</span>
<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>
<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>
<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>
@@ -206,56 +143,6 @@
<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>
<div class="viewcode-block" id="yin_functions"><a class="viewcode-back" href="../../library.html#joy.library.yin_functions">[docs]</a><span class="k">def</span> <span class="nf">yin_functions</span><span class="p">():</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a dict of named stack effects.</span>
<span class="sd"> &quot;Yin&quot; functions are those that only rearrange items in stacks and</span>
<span class="sd"> can be defined completely by their stack effects. This means they</span>
<span class="sd"> can be auto-compiled.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># pylint: disable=unused-variable</span>
<span class="n">cons</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">)((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">))</span>
<span class="n">ccons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="n">dup</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">dupd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">dupdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">first</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">),)(</span><span class="n">a1</span><span class="p">,)</span>
<span class="n">over</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)</span>
<span class="n">pop</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)()</span>
<span class="n">popd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">popdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)</span>
<span class="n">popop</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)()</span>
<span class="n">popopd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">popopdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a4</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">rest</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),)(</span><span class="n">s0</span><span class="p">,)</span>
<span class="n">rolldown</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">rollup</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">)(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)</span>
<span class="n">rrest</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span>
<span class="n">second</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">first</span><span class="p">)</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">s0</span><span class="p">)</span>
<span class="n">swaack</span> <span class="o">=</span> <span class="p">(</span><span class="n">s1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),</span> <span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="n">swap</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">swons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">swap</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="n">third</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">second</span><span class="p">)</span>
<span class="n">tuck</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">uncons</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">)</span>
<span class="n">unswons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">uncons</span><span class="p">,</span> <span class="n">swap</span><span class="p">)</span>
<span class="n">stuncons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">uncons</span><span class="p">)</span>
<span class="n">stununcons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">uncons</span><span class="p">,</span> <span class="n">uncons</span><span class="p">)</span>
<span class="n">unit</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)((</span><span class="n">a1</span><span class="p">,</span> <span class="p">()))</span>
<span class="n">first_two</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">uncons</span><span class="p">,</span> <span class="n">uncons</span><span class="p">,</span> <span class="n">pop</span><span class="p">)</span>
<span class="n">fourth</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">third</span><span class="p">)</span>
<span class="n">_Tree_add_Ee</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rrest</span><span class="p">,</span> <span class="n">ccons</span><span class="p">)</span>
<span class="n">_Tree_get_E</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">popop</span><span class="p">,</span> <span class="n">second</span><span class="p">)</span>
<span class="n">_Tree_delete_clear_stuff</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rollup</span><span class="p">,</span> <span class="n">popop</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span>
<span class="n">_Tree_delete_R0</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">over</span><span class="p">,</span> <span class="n">first</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">dup</span><span class="p">)</span>
<span class="k">return</span> <span class="nb">locals</span><span class="p">()</span></div>
<span class="n">definitions</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
<span class="s1">? dup truthy</span>
<span class="s1">*fraction [uncons] dip uncons [swap] dip concat [*] infra [*] dip cons</span>
@@ -290,6 +177,7 @@
<span class="s1">sqr dup mul</span>
<span class="s1">step_zero 0 roll&gt; step</span>
<span class="s1">swoncat swap concat</span>
<span class="s1">tailrec [i] genrec</span>
<span class="s1">ternary unary [popop] dip</span>
<span class="s1">unary nullary popd</span>
<span class="s1">unquoted [i] dip</span>
@@ -351,7 +239,6 @@
<span class="sd"> &#39;&#39;&#39;</span>
<span class="nd">@FunctionWrapper</span>
<span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="nd">@rename_code_object</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
<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>
<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>
<span class="k">return</span> <span class="n">inner</span></div>
@@ -363,7 +250,6 @@
<span class="sd"> &#39;&#39;&#39;</span>
<span class="nd">@FunctionWrapper</span>
<span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="nd">@rename_code_object</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
<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>
<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>
<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>
@@ -377,7 +263,6 @@
<span class="sd"> &#39;&#39;&#39;</span>
<span class="nd">@FunctionWrapper</span>
<span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="nd">@rename_code_object</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
<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>
<span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
@@ -426,7 +311,6 @@
<span class="sd"> Add the definition to the dictionary.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<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>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Adding definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</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="n">expression_to_string</span><span class="p">(</span><span class="n">F</span><span class="o">.</span><span class="n">body</span><span class="p">))</span>
<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>
<span class="nd">@classmethod</span>
@@ -451,7 +335,6 @@
<div class="viewcode-block" id="inscribe_"><a class="viewcode-back" href="../../library.html#joy.library.inscribe_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec0</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -478,18 +361,17 @@
<span class="k">return</span> <span class="n">expression</span><span class="p">,</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="infer_"><a class="viewcode-back" href="../../library.html#joy.library.infer_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">infer_</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Attempt to infer the stack effect of a Joy expression.&#39;&#39;&#39;</span>
<span class="n">E</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">effects</span> <span class="o">=</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">E</span><span class="p">)</span>
<span class="n">e</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">([(</span><span class="n">fi</span><span class="p">,</span> <span class="p">(</span><span class="n">fo</span><span class="p">,</span> <span class="p">()))</span> <span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">effects</span><span class="p">])</span>
<span class="k">return</span> <span class="n">e</span><span class="p">,</span> <span class="n">stack</span></div>
<span class="c1"># @inscribe</span>
<span class="c1"># @SimpleFunctionWrapper</span>
<span class="c1"># def infer_(stack):</span>
<span class="c1"># &#39;&#39;&#39;Attempt to infer the stack effect of a Joy expression.&#39;&#39;&#39;</span>
<span class="c1"># E, stack = stack</span>
<span class="c1"># effects = infer_expression(E)</span>
<span class="c1"># e = list_to_stack([(fi, (fo, ())) for fi, fo in effects])</span>
<span class="c1"># return e, stack</span>
<div class="viewcode-block" id="getitem"><a class="viewcode-back" href="../../library.html#joy.library.getitem">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec2</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">getitem</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
@@ -511,7 +393,6 @@
<div class="viewcode-block" id="drop"><a class="viewcode-back" href="../../library.html#joy.library.drop">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec1</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">drop</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
@@ -539,7 +420,6 @@
<div class="viewcode-block" id="take"><a class="viewcode-back" href="../../library.html#joy.library.take">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec1</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">take</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
@@ -614,7 +494,6 @@
<div class="viewcode-block" id="max_"><a class="viewcode-back" href="../../library.html#joy.library.max_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">max_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a list find the maximum.&#39;&#39;&#39;</span>
@@ -623,7 +502,6 @@
<div class="viewcode-block" id="min_"><a class="viewcode-back" href="../../library.html#joy.library.min_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">min_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a list find the minimum.&#39;&#39;&#39;</span>
@@ -632,7 +510,6 @@
<div class="viewcode-block" id="sum_"><a class="viewcode-back" href="../../library.html#joy.library.sum_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">sum_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a quoted sequence of numbers return the sum.</span>
@@ -679,7 +556,6 @@
<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>
<span class="n">_functions</span><span class="p">[</span><span class="s1">&#39;clear&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s1</span>
<div class="viewcode-block" id="clear"><a class="viewcode-back" href="../../library.html#joy.library.clear">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
@@ -721,7 +597,6 @@
<div class="viewcode-block" id="concat_"><a class="viewcode-back" href="../../library.html#joy.library.concat_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">concat_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Concatinate the two lists on the top of the stack.</span>
@@ -731,7 +606,7 @@
<span class="sd"> ----------------------------</span>
<span class="sd"> [a b c d e f]</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> &#39;&#39;&#39;</span>
<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>
<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>
@@ -772,7 +647,6 @@
<div class="viewcode-block" id="succ"><a class="viewcode-back" href="../../library.html#joy.library.succ">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_unary_math</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">succ</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Increment TOS.&#39;&#39;&#39;</span>
@@ -781,7 +655,6 @@
<div class="viewcode-block" id="pred"><a class="viewcode-back" href="../../library.html#joy.library.pred">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_unary_math</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">pred</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Decrement TOS.&#39;&#39;&#39;</span>
@@ -883,15 +756,15 @@
<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>
<span class="sd">&#39;&#39;&#39;Print redistribution information.&#39;&#39;&#39;</span>
<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>
<span class="s1">&#39; you receive it, in any medium, provided that you conspicuously&#39;</span>
<span class="s1">&#39; and appropriately publish on each copy an appropriate copyright&#39;</span>
<span class="s1">&#39; notice; keep intact all notices stating that this License and&#39;</span>
<span class="s1">&#39; any non-permissive terms added in accord with section 7 apply&#39;</span>
<span class="s1">&#39; to the code; keep intact all notices of the absence of any&#39;</span>
<span class="s1">&#39; warranty; and give all recipients a copy of this License along&#39;</span>
<span class="s1">&#39; with the Program.&#39;</span>
<span class="s1">&#39; You should have received a copy of the GNU General Public License&#39;</span>
<span class="s1">&#39; along with Thun. If not see &lt;http://www.gnu.org/licenses/&gt;.&#39;</span><span class="p">)</span>
<span class="s1">&#39; you receive it, in any medium, provided that you conspicuously&#39;</span>
<span class="s1">&#39; and appropriately publish on each copy an appropriate copyright&#39;</span>
<span class="s1">&#39; notice; keep intact all notices stating that this License and&#39;</span>
<span class="s1">&#39; any non-permissive terms added in accord with section 7 apply&#39;</span>
<span class="s1">&#39; to the code; keep intact all notices of the absence of any&#39;</span>
<span class="s1">&#39; warranty; and give all recipients a copy of this License along&#39;</span>
<span class="s1">&#39; with the Program.&#39;</span>
<span class="s1">&#39; You should have received a copy of the GNU General Public License&#39;</span>
<span class="s1">&#39; along with Thun. If not see &lt;http://www.gnu.org/licenses/&gt;.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
@@ -900,14 +773,14 @@
<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>
<span class="sd">&#39;&#39;&#39;Print warranty information.&#39;&#39;&#39;</span>
<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>
<span class="s1">&#39; APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE&#39;</span>
<span class="s1">&#39; COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM&#39;</span>
<span class="s1">&#39; &quot;AS IS&quot; WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR&#39;</span>
<span class="s1">&#39; IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES&#39;</span>
<span class="s1">&#39; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE&#39;</span>
<span class="s1">&#39; ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS&#39;</span>
<span class="s1">&#39; WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE&#39;</span>
<span class="s1">&#39; COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.&#39;</span><span class="p">)</span>
<span class="s1">&#39; APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE&#39;</span>
<span class="s1">&#39; COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM&#39;</span>
<span class="s1">&#39; &quot;AS IS&quot; WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR&#39;</span>
<span class="s1">&#39; IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES&#39;</span>
<span class="s1">&#39; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE&#39;</span>
<span class="s1">&#39; ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS&#39;</span>
<span class="s1">&#39; WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE&#39;</span>
<span class="s1">&#39; COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
@@ -964,7 +837,6 @@
<div class="viewcode-block" id="i"><a class="viewcode-back" href="../../library.html#joy.library.i">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -982,7 +854,6 @@
<div class="viewcode-block" id="x"><a class="viewcode-back" href="../../library.html#joy.library.x">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1000,7 +871,6 @@
<div class="viewcode-block" id="b"><a class="viewcode-back" href="../../library.html#joy.library.b">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1017,7 +887,6 @@
<div class="viewcode-block" id="dupdip"><a class="viewcode-back" href="../../library.html#joy.library.dupdip">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1037,7 +906,6 @@
<div class="viewcode-block" id="infra"><a class="viewcode-back" href="../../library.html#joy.library.infra">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1055,7 +923,6 @@
<div class="viewcode-block" id="genrec"><a class="viewcode-back" href="../../library.html#joy.library.genrec">[docs]</a><span class="nd">@inscribe</span>
<span class="c1">#@combinator_effect(_COMB_NUMS(), s7, s6, s5, s4)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1117,19 +984,18 @@
<div class="viewcode-block" id="map_"><a class="viewcode-back" href="../../library.html#joy.library.map_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Run the quoted program on TOS on the items in the list under it, push a</span>
<span class="sd"> new list with the results in place of the program and original list.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># (quote, (aggregate, stack)) = S</span>
<span class="c1"># results = list_to_stack([</span>
<span class="c1"># joy((term, stack), quote, dictionary)[0][0]</span>
<span class="c1"># for term in iter_stack(aggregate)</span>
<span class="c1"># ])</span>
<span class="c1"># return (results, stack), expression, dictionary</span>
<span class="c1"># (quote, (aggregate, stack)) = S</span>
<span class="c1"># results = list_to_stack([</span>
<span class="c1"># joy((term, stack), quote, dictionary)[0][0]</span>
<span class="c1"># for term in iter_stack(aggregate)</span>
<span class="c1"># ])</span>
<span class="c1"># return (results, stack), expression, dictionary</span>
<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>
<span class="k">if</span> <span class="ow">not</span> <span class="n">aggregate</span><span class="p">:</span>
<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>
@@ -1198,20 +1064,7 @@
<span class="c1"># return (q, (p, stack)), expression, dictionary</span>
<span class="k">def</span> <span class="nf">branch_true</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=unused-variable</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="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>
<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="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">branch_false</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=unused-variable</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="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>
<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">else_</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span>
<div class="viewcode-block" id="branch"><a class="viewcode-back" href="../../library.html#joy.library.branch">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@poly_combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="p">[</span><span class="n">branch_true</span><span class="p">,</span> <span class="n">branch_false</span><span class="p">],</span> <span class="n">b1</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1236,9 +1089,6 @@
<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>
<span class="c1">#FUNCTIONS[&#39;branch&#39;] = CombinatorJoyType(&#39;branch&#39;, [branch_true, branch_false], 100)</span>
<span class="c1">##@inscribe</span>
<span class="c1">##@FunctionWrapper</span>
<span class="c1">##def ifte(stack, expression, dictionary):</span>
@@ -1308,7 +1158,6 @@
<div class="viewcode-block" id="dip"><a class="viewcode-back" href="../../library.html#joy.library.dip">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1328,7 +1177,6 @@
<div class="viewcode-block" id="dipd"><a class="viewcode-back" href="../../library.html#joy.library.dipd">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1346,7 +1194,6 @@
<div class="viewcode-block" id="dipdd"><a class="viewcode-back" href="../../library.html#joy.library.dipdd">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1364,7 +1211,6 @@
<div class="viewcode-block" id="app1"><a class="viewcode-back" href="../../library.html#joy.library.app1">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1384,7 +1230,6 @@
<div class="viewcode-block" id="app2"><a class="viewcode-back" href="../../library.html#joy.library.app2">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;Like app1 with two items.</span>
@@ -1405,7 +1250,6 @@
<div class="viewcode-block" id="app3"><a class="viewcode-back" href="../../library.html#joy.library.app3">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;Like app1 with three items.</span>
@@ -1428,7 +1272,6 @@
<div class="viewcode-block" id="step"><a class="viewcode-back" href="../../library.html#joy.library.step">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1464,7 +1307,6 @@
<div class="viewcode-block" id="times"><a class="viewcode-back" href="../../library.html#joy.library.times">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">i1</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1513,21 +1355,7 @@
<span class="c1"># return stack, expression, dictionary</span>
<span class="k">def</span> <span class="nf">loop_true</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">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> <span class="c1"># pylint: disable=unused-variable</span>
<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="p">(</span><span class="n">S_pop</span><span class="p">,</span> <span class="n">expression</span><span class="p">)),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">loop_two_true</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">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> <span class="c1"># pylint: disable=unused-variable</span>
<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="p">(</span><span class="n">S_pop</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">S_pop</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">loop_false</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">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> <span class="c1"># pylint: disable=unused-variable</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
<div class="viewcode-block" id="loop"><a class="viewcode-back" href="../../library.html#joy.library.loop">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@poly_combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="p">[</span><span class="n">loop_two_true</span><span class="p">,</span> <span class="n">loop_true</span><span class="p">,</span> <span class="n">loop_false</span><span class="p">],</span> <span class="n">b1</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<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>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1550,7 +1378,6 @@
<div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">s6</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s8</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
@@ -1583,137 +1410,50 @@
<span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</span>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<span class="n">sec_binary_cmp</span><span class="p">(</span><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>
<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>
<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>
<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>
<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>
<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>
<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>
<span class="n">sec_binary_ints</span><span class="p">(</span><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>
<span class="n">sec_binary_ints</span><span class="p">(</span><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>
<span class="n">sec_binary_ints</span><span class="p">(</span><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>
<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>
<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>
<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>
<span class="n">sec_binary_logic</span><span class="p">(</span><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>
<span class="n">sec_binary_logic</span><span class="p">(</span><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>
<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>
<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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<span class="n">sec_binary_math</span><span class="p">(</span><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>
<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>
<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>
<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>
<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>
<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>
<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>
<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>
<span class="n">sec_unary_logic</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">)),</span>
<span class="n">sec_unary_logic</span><span class="p">(</span><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>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">),</span>
<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>
<span class="n">sec_unary_math</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">abs</span><span class="p">)),</span>
<span class="n">sec_unary_math</span><span class="p">(</span><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>
<span class="n">sec_unary_math</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">)),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">abs</span><span class="p">),</span>
<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>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">),</span>
<span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">)(</span><span class="n">i1</span><span class="p">)(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">floor</span><span class="p">)),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">floor</span><span class="p">),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">round</span><span class="p">),</span>
<span class="p">):</span>
<span class="n">inscribe</span><span class="p">(</span><span class="n">F</span><span class="p">)</span>
<span class="k">del</span> <span class="n">F</span> <span class="c1"># Otherwise Sphinx autodoc will pick it up.</span>
<span class="n">YIN_STACK_EFFECTS</span> <span class="o">=</span> <span class="n">yin_functions</span><span class="p">()</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">YIN_STACK_EFFECTS</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="c1"># Load the auto-generated primitives into the dictionary.</span>
<span class="n">_functions</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">YIN_STACK_EFFECTS</span><span class="p">)</span>
<span class="c1"># exec &#39;&#39;&#39;</span>
<span class="c1"># eh = compose(dup, bool)</span>
<span class="c1"># sqr = compose(dup, mul)</span>
<span class="c1"># of = compose(swap, at)</span>
<span class="c1"># &#39;&#39;&#39; in dict(compose=compose), _functions</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">_functions</span><span class="p">):</span>
<span class="n">sec</span> <span class="o">=</span> <span class="n">_functions</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">F</span> <span class="o">=</span> <span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">SymbolJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="p">[</span><span class="n">sec</span><span class="p">],</span> <span class="n">_SYM_NUMS</span><span class="p">())</span>
<span class="k">if</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">YIN_STACK_EFFECTS</span><span class="p">:</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Setting stack effect for Yin function </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</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="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">sec</span><span class="p">))</span>
<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>
<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>
<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>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">_functions</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">FUNCTIONS</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<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>
<span class="n">EXPECTATIONS</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span>
<span class="n">ifte</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="p">(</span><span class="n">s6</span><span class="p">,</span> <span class="p">(</span><span class="n">s5</span><span class="p">,</span> <span class="n">s4</span><span class="p">))),</span>
<span class="n">nullary</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">),</span>
<span class="n">run</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">),</span>
<span class="p">)</span>
<span class="n">EXPECTATIONS</span><span class="p">[</span><span class="s1">&#39;while&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="p">(</span><span class="n">s6</span><span class="p">,</span> <span class="n">s5</span><span class="p">))</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="s1">&#39;&#39;&#39;</span>
<span class="s1"> dinfrirst</span>
<span class="s1"> nullary</span>
<span class="s1"> ifte</span>
<span class="s1"> run</span>
<span class="s1"> dupdipd codireco</span>
<span class="s1"> while</span>
<span class="s1"> &#39;&#39;&#39;</span><span class="o">.</span><span class="n">split</span><span class="p">():</span>
<span class="n">C</span> <span class="o">=</span> <span class="n">_dictionary</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">expect</span> <span class="o">=</span> <span class="n">EXPECTATIONS</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
<span class="k">if</span> <span class="n">expect</span><span class="p">:</span>
<span class="n">sec</span> <span class="o">=</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">expect</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Setting stack EXPECT for combinator </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">C</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">sec</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;combinator </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">C</span><span class="o">.</span><span class="n">name</span><span class="p">)</span>
<span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">CombinatorJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="p">[</span><span class="n">C</span><span class="p">],</span> <span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">expect</span><span class="p">)</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1"> of quoted enstacken ?</span>
<span class="s1"> unary binary ternary</span>
<span class="s1"> sqr unquoted</span>
<span class="s1"> &#39;&#39;&#39;</span><span class="o">.</span><span class="n">split</span><span class="p">()):</span>
<span class="n">of_</span> <span class="o">=</span> <span class="n">_dictionary</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">secs</span> <span class="o">=</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">of_</span><span class="o">.</span><span class="n">body</span><span class="p">)</span>
<span class="k">assert</span> <span class="nb">len</span><span class="p">(</span><span class="n">secs</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">,</span> <span class="nb">repr</span><span class="p">(</span><span class="n">secs</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span>
<span class="s1">&#39;Setting stack effect for definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span>
<span class="n">name</span><span class="p">,</span>
<span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">secs</span><span class="p">[</span><span class="mi">0</span><span class="p">]),</span>
<span class="p">)</span>
<span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">SymbolJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">of_</span><span class="o">.</span><span class="n">body</span><span class="p">),</span> <span class="n">_SYM_NUMS</span><span class="p">())</span>
<span class="c1">#sec_Ns_math(_dictionary[&#39;product&#39;])</span>
<span class="c1">## product == 1 swap [*] step</span>
<span class="c1">## flatten == [] swap [concat] step</span>
<span class="c1">## pam == [i] map</span>
<span class="c1">## size == 0 swap [pop ++] step</span>
<span class="c1">## fork == [i] app2</span>
<span class="c1">## cleave == fork [popd] dip</span>
<span class="c1">## average == [sum 1.0 *] [size] cleave /</span>
<span class="c1">## gcd == 1 [tuck modulus dup 0 &gt;] loop pop</span>
<span class="c1">## least_fraction == dup [gcd] infra [div] concat map</span>
<span class="c1">## *fraction == [uncons] dip uncons [swap] dip concat [*] infra [*] dip cons</span>
<span class="c1">## *fraction0 == concat [[swap] dip * [*] dip] infra</span>
<span class="c1">## down_to_zero == [0 &gt;] [dup --] while</span>
<span class="c1">## range_to_zero == unit [down_to_zero] infra</span>
<span class="c1">## anamorphism == [pop []] swap [dip swons] genrec</span>
<span class="c1">## range == [0 &lt;=] [1 - dup] anamorphism</span>
<span class="c1">## while == swap [nullary] cons dup dipd concat loop</span>
<span class="c1">## dupdipd == dup dipd</span>
<span class="c1">## tailrec == [i] genrec</span>
<span class="c1">## step_zero == 0 roll&gt; step</span>
<span class="c1">## codireco == cons dip rest cons</span>
<span class="c1">## make_generator == [codireco] ccons</span>
<span class="c1">## ifte == [nullary not] dipd branch</span>
</pre></div>
</div>
docs/sphinx_docs/_build/html/_modules/joy/parser.html
+1 -1
View File
@@ -74,7 +74,7 @@
<span class="c1">#TODO: explain the details of float lits and strings.</span>
<span class="n">FLOAT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*(e(-|\+)\d+)+&#39;</span>
<span class="n">FLOAT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*(e(-|\+)\d+)?&#39;</span>
<span class="n">INT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+&#39;</span>
<span class="n">SYMBOL</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;[•\w!@$%^&amp;*()_+&lt;&gt;?|\/;:`~,.=-]+&#39;</span>
<span class="n">BRACKETS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</span>
docs/sphinx_docs/_build/html/genindex.html
+9 -100
View File
@@ -45,10 +45,8 @@
| <a href="#H"><strong>H</strong></a>
| <a href="#I"><strong>I</strong></a>
| <a href="#J"><strong>J</strong></a>
| <a href="#K"><strong>K</strong></a>
| <a href="#L"><strong>L</strong></a>
| <a href="#M"><strong>M</strong></a>
| <a href="#N"><strong>N</strong></a>
| <a href="#O"><strong>O</strong></a>
| <a href="#P"><strong>P</strong></a>
| <a href="#R"><strong>R</strong></a>
@@ -58,35 +56,20 @@
| <a href="#V"><strong>V</strong></a>
| <a href="#W"><strong>W</strong></a>
| <a href="#X"><strong>X</strong></a>
| <a href="#Y"><strong>Y</strong></a>
| <a href="#Z"><strong>Z</strong></a>
</div>
<h2 id="A">A</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.BooleanJoyType.accept">accept (joy.utils.types.BooleanJoyType attribute)</a>
<ul>
<li><a href="types.html#joy.utils.types.FloatJoyType.accept">(joy.utils.types.FloatJoyType attribute)</a>
</li>
<li><a href="types.html#joy.utils.types.IntJoyType.accept">(joy.utils.types.IntJoyType attribute)</a>
</li>
<li><a href="types.html#joy.utils.types.StackJoyType.accept">(joy.utils.types.StackJoyType attribute)</a>
</li>
<li><a href="types.html#joy.utils.types.TextJoyType.accept">(joy.utils.types.TextJoyType attribute)</a>
</li>
</ul></li>
<li><a href="library.html#joy.library.add_aliases">add_aliases() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.DefinitionWrapper.add_def">add_def() (joy.library.DefinitionWrapper class method)</a>
</li>
<li><a href="library.html#joy.library.DefinitionWrapper.add_definitions">add_definitions() (joy.library.DefinitionWrapper class method)</a>
</li>
<li><a href="types.html#joy.utils.types.AnyJoyType">AnyJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.app1">app1() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.app2">app2() (in module joy.library)</a>
@@ -100,12 +83,10 @@
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.b">b() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.BinaryBuiltinWrapper">BinaryBuiltinWrapper() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.BooleanJoyType">BooleanJoyType (class in joy.utils.types)</a>
<li><a href="library.html#joy.library.BinaryBuiltinWrapper">BinaryBuiltinWrapper() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.branch">branch() (in module joy.library)</a>
</li>
@@ -122,17 +103,9 @@
<li><a href="library.html#joy.library.clear">clear() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.cmp_">cmp_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.CombinatorJoyType">CombinatorJoyType (class in joy.utils.types)</a>
</li>
<li><a href="types.html#joy.utils.types.compilable">compilable() (in module joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.compile_">compile_() (in module joy.utils.types)</a>
</li>
<li><a href="types.html#joy.utils.types.compose">compose() (in module joy.utils.types)</a>
</li>
<li><a href="stack.html#joy.utils.stack.concat">concat() (in module joy.utils.stack)</a>
</li>
<li><a href="library.html#joy.library.concat_">concat_() (in module joy.library)</a>
@@ -148,8 +121,6 @@
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.DefinitionWrapper">DefinitionWrapper (class in joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.delabel">delabel() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.dip">dip() (in module joy.library)</a>
</li>
@@ -162,8 +133,6 @@
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.divmod_">divmod_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.doc_from_stack_effect">doc_from_stack_effect() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.drop">drop() (in module joy.library)</a>
</li>
@@ -192,16 +161,12 @@
<li><a href="library.html#joy.utils.generated_library.first">first() (in module joy.utils.generated_library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.first_two">first_two() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.FloatJoyType">FloatJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.floor">floor() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.fourth">fourth() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.FunctionJoyType">FunctionJoyType (class in joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.FunctionWrapper">FunctionWrapper() (in module joy.library)</a>
</li>
@@ -236,10 +201,6 @@
<li><a href="library.html#joy.library.i">i() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.id_">id_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.infer">infer() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.infer_">infer_() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.infra">infra() (in module joy.library)</a>
</li>
@@ -250,8 +211,6 @@
<li><a href="library.html#joy.library.inscribe">inscribe() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.inscribe_">inscribe_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.IntJoyType">IntJoyType (class in joy.utils.types)</a>
</li>
<li><a href="stack.html#joy.utils.stack.iter_stack">iter_stack() (in module joy.utils.stack)</a>
</li>
@@ -266,32 +225,16 @@
<li><a href="joy.html#module-joy.joy">joy.joy (module)</a>
</li>
<li><a href="library.html#module-joy.library">joy.library (module)</a>
</li>
<li><a href="parser.html#module-joy.parser">joy.parser (module)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="parser.html#module-joy.parser">joy.parser (module)</a>
</li>
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a>
</li>
<li><a href="pretty.html#module-joy.utils.pretty_print">joy.utils.pretty_print (module)</a>
</li>
<li><a href="stack.html#module-joy.utils.stack">joy.utils.stack (module)</a>
</li>
<li><a href="types.html#module-joy.utils.types">joy.utils.types (module)</a>
</li>
<li><a href="types.html#joy.utils.types.JoyTypeError">JoyTypeError</a>
</li>
</ul></td>
</tr></table>
<h2 id="K">K</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.KleeneStar.kind">kind (joy.utils.types.KleeneStar attribute)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.KleeneStar">KleeneStar (class in joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@@ -313,25 +256,15 @@
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.map_">map_() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.max_">max_() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.meta_compose">meta_compose() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.min_">min_() (in module joy.library)</a>
</li>
</ul></td>
</tr></table>
<h2 id="N">N</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.NumberJoyType">NumberJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
<h2 id="O">O</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
@@ -352,8 +285,6 @@
<li><a href="stack.html#joy.utils.stack.pick">pick() (in module joy.utils.stack)</a>
</li>
<li><a href="library.html#joy.library.pm">pm() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.poly_compose">poly_compose() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.pop">pop() (in module joy.utils.generated_library)</a>
</li>
@@ -379,20 +310,16 @@
<h2 id="R">R</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.reify">reify() (in module joy.utils.types)</a>
</li>
<li><a href="types.html#joy.utils.types.relabel">relabel() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.remove">remove() (in module joy.library)</a>
</li>
<li><a href="joy.html#joy.joy.repl">repl() (in module joy.joy)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.rest">rest() (in module joy.utils.generated_library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.reverse">reverse() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.utils.generated_library.rolldown">rolldown() (in module joy.utils.generated_library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.rollup">rollup() (in module joy.utils.generated_library)</a>
@@ -424,8 +351,6 @@
<li><a href="library.html#joy.utils.generated_library.stack">stack() (in module joy.utils.generated_library)</a>
</li>
<li><a href="stack.html#joy.utils.stack.stack_to_string">stack_to_string() (in module joy.utils.stack)</a>
</li>
<li><a href="types.html#joy.utils.types.StackJoyType">StackJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
@@ -446,8 +371,6 @@
<li><a href="library.html#joy.utils.generated_library.swons">swons() (in module joy.utils.generated_library)</a>
</li>
<li><a href="parser.html#joy.parser.Symbol">Symbol (class in joy.parser)</a>
</li>
<li><a href="types.html#joy.utils.types.SymbolJoyType">SymbolJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@@ -458,8 +381,6 @@
<li><a href="library.html#joy.library.take">take() (in module joy.library)</a>
</li>
<li><a href="parser.html#joy.parser.text_to_expression">text_to_expression() (in module joy.parser)</a>
</li>
<li><a href="types.html#joy.utils.types.TextJoyType">TextJoyType (class in joy.utils.types)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.third">third() (in module joy.utils.generated_library)</a>
</li>
@@ -472,8 +393,6 @@
<li><a href="pretty.html#joy.utils.pretty_print.TracePrinter">TracePrinter (class in joy.utils.pretty_print)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.tuck">tuck() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.type_check">type_check() (in module joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@@ -484,8 +403,6 @@
<li><a href="library.html#joy.library.UnaryBuiltinWrapper">UnaryBuiltinWrapper() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.uncons">uncons() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.uni_unify">uni_unify() (in module joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
@@ -530,14 +447,6 @@
</ul></td>
</tr></table>
<h2 id="Y">Y</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.yin_functions">yin_functions() (in module joy.library)</a>
</li>
</ul></td>
</tr></table>
<h2 id="Z">Z</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
docs/sphinx_docs/_build/html/library.html
+9 -69
View File
@@ -294,8 +294,7 @@ the stack discarding the rest of the stack.</p>
<dl class="function">
<dt id="joy.library.drop">
<code class="descclassname">joy.library.</code><code class="descname">drop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#drop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.drop" title="Permalink to this definition"></a></dt>
<dd><blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
</pre></div>
</div>
<p>Expects an integer and a quote on the stack and returns the quote with
@@ -305,11 +304,6 @@ n items removed off the top.</p>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -382,8 +376,7 @@ the original definition in the else-part:</p>
<dl class="function">
<dt id="joy.library.getitem">
<code class="descclassname">joy.library.</code><code class="descname">getitem</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#getitem"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.getitem" title="Permalink to this definition"></a></dt>
<dd><blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
</pre></div>
</div>
<p>Expects an integer and a quote on the stack and returns the item at the
@@ -393,11 +386,6 @@ nth position in the quote counting from 0.</p>
<span class="n">a</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="n">a1</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -424,12 +412,6 @@ onto the pending expression for evaluation.</p>
<dd><p>The identity function.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.infer_">
<code class="descclassname">joy.library.</code><code class="descname">infer_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infer_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infer_" title="Permalink to this definition"></a></dt>
<dd><p>Attempt to infer the stack effect of a Joy expression.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.infra">
<code class="descclassname">joy.library.</code><code class="descname">infra</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infra"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infra" title="Permalink to this definition"></a></dt>
@@ -457,19 +439,13 @@ with the list as its stack. Does not affect the rest of the stack.</p>
<dl class="function">
<dt id="joy.library.inscribe_">
<code class="descclassname">joy.library.</code><code class="descname">inscribe_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#inscribe_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.inscribe_" title="Permalink to this definition"></a></dt>
<dd><blockquote>
<div><p>Create a new Joy function definition in the Joy dictionary. A
<dd><p>Create a new Joy function definition in the Joy dictionary. A
definition is given as a string with a name followed by a double
equal sign then one or more Joy functions, the body. for example:</p>
<blockquote>
<div>sqr == dup mul</div></blockquote>
<p>If you want the definition to persist over restarts, enter it into
the definitions.txt resource.</p>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">t1</span> <span class="o">--</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -497,21 +473,13 @@ new list with the results in place of the program and original list.</p>
<dl class="function">
<dt id="joy.library.max_">
<code class="descclassname">joy.library.</code><code class="descname">max_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#max_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.max_" title="Permalink to this definition"></a></dt>
<dd><p>Given a list find the maximum.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
<dd><p>Given a list find the maximum.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.min_">
<code class="descclassname">joy.library.</code><code class="descname">min_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#min_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.min_" title="Permalink to this definition"></a></dt>
<dd><p>Given a list find the minimum.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
<dd><p>Given a list find the minimum.</p>
</dd></dl>
<dl class="function">
@@ -534,11 +502,7 @@ Stack effect:</p>
<dl class="function">
<dt id="joy.library.pred">
<code class="descclassname">joy.library.</code><code class="descname">pred</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pred"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pred" title="Permalink to this definition"></a></dt>
<dd><p>Decrement TOS.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
</pre></div>
</div>
<dd><p>Decrement TOS.</p>
</dd></dl>
<dl class="function">
@@ -673,30 +637,20 @@ on top of the stack.</p>
<dl class="function">
<dt id="joy.library.succ">
<code class="descclassname">joy.library.</code><code class="descname">succ</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#succ"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.succ" title="Permalink to this definition"></a></dt>
<dd><p>Increment TOS.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
</pre></div>
</div>
<dd><p>Increment TOS.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.sum_">
<code class="descclassname">joy.library.</code><code class="descname">sum_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#sum_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.sum_" title="Permalink to this definition"></a></dt>
<dd><p>Given a quoted sequence of numbers return the sum.</p>
<blockquote>
<div>sum == 0 swap [+] step</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
<p>sum == 0 swap [+] step</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.take">
<code class="descclassname">joy.library.</code><code class="descname">take</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#take"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.take" title="Permalink to this definition"></a></dt>
<dd><blockquote>
<div><p>Expects an integer and a quote on the stack and returns the quote with
<dd><p>Expects an integer and a quote on the stack and returns the quote with
just the top n items in reverse order (because that’s easier and you can
use reverse if needed.)</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
@@ -704,11 +658,6 @@ use reverse if needed.)</p>
<span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -768,15 +717,6 @@ use reverse if needed.)</p>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.yin_functions">
<code class="descclassname">joy.library.</code><code class="descname">yin_functions</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#yin_functions"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.yin_functions" title="Permalink to this definition"></a></dt>
<dd><p>Return a dict of named stack effects.</p>
<p>“Yin” functions are those that only rearrange items in stacks and
can be defined completely by their stack effects. This means they
can be auto-compiled.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.zip_">
<code class="descclassname">joy.library.</code><code class="descname">zip_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#zip_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.zip_" title="Permalink to this definition"></a></dt>
docs/sphinx_docs/_build/html/objects.inv
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/html/py-modindex.html
-5
View File
@@ -80,11 +80,6 @@
<td>&#160;&#160;&#160;
<a href="stack.html#module-joy.utils.stack"><code class="xref">joy.utils.stack</code></a></td><td>
<em></em></td></tr>
<tr class="cg-1">
<td></td>
<td>&#160;&#160;&#160;
<a href="types.html#module-joy.utils.types"><code class="xref">joy.utils.types</code></a></td><td>
<em></em></td></tr>
</table>
docs/sphinx_docs/_build/html/searchindex.js
+1 -1
View File
File diff suppressed because one or more lines are too long
docs/sphinx_docs/_build/html/types.html
-208
View File
@@ -107,214 +107,6 @@ auto-compiled to Python):</p>
<span class="n">unswons</span> <span class="o">=</span> <span class="p">([</span><span class="n">a1</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a1</span><span class="p">)</span> <span class="o">*</span>
</pre></div>
</div>
<span class="target" id="module-joy.utils.types"></span><dl class="class">
<dt id="joy.utils.types.AnyJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">AnyJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#AnyJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.AnyJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Joy type variable. Represents any Joy value.</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.BooleanJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">BooleanJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#BooleanJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.BooleanJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.BooleanJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.BooleanJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.bool</span></code></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.CombinatorJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.CombinatorJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent combinators.</p>
<p>These type variables carry Joy functions that implement the
behaviour of Joy combinators and they can appear in expressions.
For simple combinators the implementation functions can be the
combinators themselves.</p>
<p>These types can also specify a stack effect (input side only) to
guard against being used on invalid types.</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.FloatJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FloatJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FloatJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FloatJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.FloatJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.FloatJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.float</span></code></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.FunctionJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FunctionJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FunctionJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FunctionJoyType" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.types.IntJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">IntJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#IntJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.IntJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.IntJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.IntJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.int</span></code></p>
</dd></dl>
</dd></dl>
<dl class="exception">
<dt id="joy.utils.types.JoyTypeError">
<em class="property">exception </em><code class="descclassname">joy.utils.types.</code><code class="descname">JoyTypeError</code><a class="reference internal" href="_modules/joy/utils/types.html#JoyTypeError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.JoyTypeError" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.types.KleeneStar">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">KleeneStar</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#KleeneStar"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.KleeneStar" title="Permalink to this definition"></a></dt>
<dd><p>A sequence of zero or more <cite>AnyJoyType</cite> variables would be:</p>
<blockquote>
<div>A*</div></blockquote>
<p>The <cite>A*</cite> works by splitting the universe into two alternate histories:</p>
<blockquote>
<div><p>A* → ∅</p>
<p>A* → A A*</p>
</div></blockquote>
<p>The Kleene star variable disappears in one universe, and in the other
it turns into an <cite>AnyJoyType</cite> variable followed by itself again.</p>
<p>We have to return all universes (represented by their substitution
dicts, the “unifiers”) that don’t lead to type conflicts.</p>
<dl class="attribute">
<dt id="joy.utils.types.KleeneStar.kind">
<code class="descname">kind</code><a class="headerlink" href="#joy.utils.types.KleeneStar.kind" title="Permalink to this definition"></a></dt>
<dd><p>alias of <a class="reference internal" href="#joy.utils.types.AnyJoyType" title="joy.utils.types.AnyJoyType"><code class="xref py py-class docutils literal notranslate"><span class="pre">AnyJoyType</span></code></a></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.NumberJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">NumberJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#NumberJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.NumberJoyType" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.types.StackJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">StackJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#StackJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.StackJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.StackJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.StackJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.tuple</span></code></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.SymbolJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">SymbolJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#SymbolJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.SymbolJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent non-combinator functions.</p>
<p>These type variables carry the stack effect comments and can
appear in expressions (as in quoted programs.)</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.TextJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">TextJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#TextJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.TextJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.TextJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.TextJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.basestring</span></code></p>
</dd></dl>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.compilable">
<code class="descclassname">joy.utils.types.</code><code class="descname">compilable</code><span class="sig-paren">(</span><em>f</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compilable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compilable" title="Permalink to this definition"></a></dt>
<dd><p>Return True if a stack effect represents a function that can be
automatically compiled (to Python), False otherwise.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.compile_">
<code class="descclassname">joy.utils.types.</code><code class="descname">compile_</code><span class="sig-paren">(</span><em>name</em>, <em>f</em>, <em>doc=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compile_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compile_" title="Permalink to this definition"></a></dt>
<dd><p>Return a string of Python code implementing the function described
by the stack effect. If no doc string is passed doc_from_stack_effect()
is used to generate one.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.compose">
<code class="descclassname">joy.utils.types.</code><code class="descname">compose</code><span class="sig-paren">(</span><em>*functions</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compose" title="Permalink to this definition"></a></dt>
<dd><p>Return the stack effect of the composition of some of stack effects.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.delabel">
<code class="descclassname">joy.utils.types.</code><code class="descname">delabel</code><span class="sig-paren">(</span><em>f</em>, <em>seen=None</em>, <em>c=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#delabel"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.delabel" title="Permalink to this definition"></a></dt>
<dd><p>Fix up type variable numbers after relabel().</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.doc_from_stack_effect">
<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs=('??'</em>, <em>())</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition"></a></dt>
<dd><p>Return a crude string representation of a stack effect.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.infer">
<code class="descclassname">joy.utils.types.</code><code class="descname">infer</code><span class="sig-paren">(</span><em>*expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#infer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.infer" title="Permalink to this definition"></a></dt>
<dd><p>Return a list of stack effects for a Joy expression.</p>
<p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">h</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">h</span><span class="p">:</span>
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span>
</pre></div>
</div>
<p>Prints:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.meta_compose">
<code class="descclassname">joy.utils.types.</code><code class="descname">meta_compose</code><span class="sig-paren">(</span><em>F</em>, <em>G</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#meta_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.meta_compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two lists of stack
effects. An expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.poly_compose">
<code class="descclassname">joy.utils.types.</code><code class="descname">poly_compose</code><span class="sig-paren">(</span><em>f</em>, <em>g</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#poly_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.poly_compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two stack effects. An
expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.reify">
<code class="descclassname">joy.utils.types.</code><code class="descname">reify</code><span class="sig-paren">(</span><em>meaning</em>, <em>name</em>, <em>seen=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#reify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.reify" title="Permalink to this definition"></a></dt>
<dd><p>Apply substitution dict to term, returning new term.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.relabel">
<code class="descclassname">joy.utils.types.</code><code class="descname">relabel</code><span class="sig-paren">(</span><em>left</em>, <em>right</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#relabel"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.relabel" title="Permalink to this definition"></a></dt>
<dd><p>Re-number type variables to avoid collisions between stack effects.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.type_check">
<code class="descclassname">joy.utils.types.</code><code class="descname">type_check</code><span class="sig-paren">(</span><em>name</em>, <em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#type_check"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.type_check" title="Permalink to this definition"></a></dt>
<dd><p>Trinary predicate. True if named function type-checks, False if it
fails, None if it’s indeterminate (because I haven’t entered it into
the FUNCTIONS dict yet.)</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.uni_unify">
<code class="descclassname">joy.utils.types.</code><code class="descname">uni_unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#uni_unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.uni_unify" title="Permalink to this definition"></a></dt>
<dd><p>Return a substitution dict representing a unifier for u and v.</p>
</dd></dl>
<p>Example output of the <code class="docutils literal notranslate"><span class="pre">infer()</span></code> function. The first number on each
line is the depth of the Python stack. It goes down when the function
backtracks. The next thing on each line is the currently-computed stack