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

Update some of the docs.

Browse Source
This commit is contained in:
Simon Forman
2020-05-20 19:15:47 -07:00
parent 6a6b63bf62
commit ffabda0407
60 changed files with 5182 additions and 5853 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/sphinx_docs/_build/html/_modules/joy/joy.html
+2 -3
View File
@@ -58,7 +58,7 @@
<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">input</span>
<span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="p">,</span> <span class="n">format_exc</span>
<span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</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">ParseError</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">stack_to_string</span>
@@ -136,8 +136,7 @@
<span class="k">try</span><span class="p">:</span>
<span class="n">stack</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="n">run</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span>
<span class="k">except</span><span class="p">:</span>
<span class="n">exc</span> <span class="o">=</span> <span class="n">format_exc</span><span class="p">()</span> <span class="c1"># Capture the exception.</span>
<span class="nb">print</span><span class="p">(</span><span class="n">exc</span><span class="p">)</span> <span class="c1"># Print the original exception.</span>
<span class="n">print_exc</span><span class="p">()</span>
<span class="k">except</span><span class="p">:</span>
<span class="n">print_exc</span><span class="p">()</span>
<span class="nb">print</span><span class="p">()</span>
docs/sphinx_docs/_build/html/_modules/joy/library.html
+119 -115
View File
@@ -56,12 +56,9 @@
<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">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">inspect</span> <span class="k">import</span> <span class="n">getdoc</span>
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getdoc</span><span class="p">,</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span>
<span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span>
<span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">count</span>
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span>
<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>
@@ -325,7 +322,7 @@
<span class="k">return</span> <span class="p">(</span>
<span class="n">line</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
<span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">line</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;#&#39;</span><span class="p">)</span>
<span class="k">if</span> <span class="n">line</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">line</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;#&#39;</span><span class="p">)</span>
<span class="p">)</span>
@@ -342,7 +339,7 @@
<span class="sd"> definition is given as a string with a name followed by a double</span>
<span class="sd"> equal sign then one or more Joy functions, the body. for example:</span>
<span class="sd"> sqr == dup mul</span>
<span class="sd"> sqr == dup mul</span>
<span class="sd"> If you want the definition to persist over restarts, enter it into</span>
<span class="sd"> the definitions.txt resource.</span>
@@ -383,9 +380,9 @@
<span class="sd"> nth position in the quote counting from 0.</span>
<span class="sd"> ::</span>
<span class="sd"> [a b c d] 0 getitem</span>
<span class="sd"> [a b c d] 0 getitem</span>
<span class="sd"> -------------------------</span>
<span class="sd"> a</span>
<span class="sd"> a</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
@@ -404,9 +401,9 @@
<span class="sd"> n items removed off the top.</span>
<span class="sd"> ::</span>
<span class="sd"> [a b c d] 2 drop</span>
<span class="sd"> [a b c d] 2 drop</span>
<span class="sd"> ----------------------</span>
<span class="sd"> [c d]</span>
<span class="sd"> [c d]</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
@@ -428,9 +425,9 @@
<span class="sd"> use reverse if needed.)</span>
<span class="sd"> ::</span>
<span class="sd"> [a b c d] 2 take</span>
<span class="sd"> [a b c d] 2 take</span>
<span class="sd"> ----------------------</span>
<span class="sd"> [b a]</span>
<span class="sd"> [b a]</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">n</span><span class="p">,</span> <span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span>
@@ -452,14 +449,14 @@
<span class="sd"> Use a Boolean value to select one of two items.</span>
<span class="sd"> ::</span>
<span class="sd"> A B False choice</span>
<span class="sd"> ----------------------</span>
<span class="sd"> A</span>
<span class="sd"> A B False choice</span>
<span class="sd"> ----------------------</span>
<span class="sd"> A</span>
<span class="sd"> A B True choice</span>
<span class="sd"> ---------------------</span>
<span class="sd"> B</span>
<span class="sd"> A B True choice</span>
<span class="sd"> ---------------------</span>
<span class="sd"> B</span>
<span class="sd"> Currently Python semantics are used to evaluate the &quot;truthiness&quot; of the</span>
<span class="sd"> Boolean value (so empty string, zero, etc. are counted as false, etc.)</span>
@@ -475,14 +472,14 @@
<span class="sd"> Use a Boolean value to select one of two items from a sequence.</span>
<span class="sd"> ::</span>
<span class="sd"> [A B] False select</span>
<span class="sd"> ------------------------</span>
<span class="sd"> A</span>
<span class="sd"> [A B] False select</span>
<span class="sd"> ------------------------</span>
<span class="sd"> A</span>
<span class="sd"> [A B] True select</span>
<span class="sd"> -----------------------</span>
<span class="sd"> B</span>
<span class="sd"> [A B] True select</span>
<span class="sd"> -----------------------</span>
<span class="sd"> B</span>
<span class="sd"> The sequence can contain more than two items but not fewer.</span>
<span class="sd"> Currently Python semantics are used to evaluate the &quot;truthiness&quot; of the</span>
@@ -512,9 +509,12 @@
<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">@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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Given a quoted sequence of numbers return the sum.</span>
<span class="sd"> ::</span>
<span class="sd"> sum == 0 swap [+] step</span>
<span class="sd"> sum == 0 swap [+] step</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
<span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">)),</span> <span class="n">stack</span></div>
@@ -528,9 +528,9 @@
<span class="sd"> from the the quote. The item is only removed once.</span>
<span class="sd"> ::</span>
<span class="sd"> [1 2 3 1] 1 remove</span>
<span class="sd"> [1 2 3 1] 1 remove</span>
<span class="sd"> ------------------------</span>
<span class="sd"> [2 3 1]</span>
<span class="sd"> [2 3 1]</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>
@@ -564,7 +564,7 @@
<span class="sd"> clear == stack [pop stack] loop</span>
<span class="sd"> ... clear</span>
<span class="sd"> ... clear</span>
<span class="sd"> ---------------</span>
<span class="sd"> &#39;&#39;&#39;</span>
@@ -584,7 +584,8 @@
<div class="viewcode-block" id="reverse"><a class="viewcode-back" href="../../library.html#joy.library.reverse">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Reverse the list on the top of the stack.</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Reverse the list on the top of the stack.</span>
<span class="sd"> ::</span>
<span class="sd"> reverse == [] swap shunt</span>
@@ -599,12 +600,13 @@
<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">@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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Concatinate the two lists on the top of the stack.</span>
<span class="sd"> ::</span>
<span class="sd"> [a b c] [d e f] concat</span>
<span class="sd"> [a b c] [d e f] concat</span>
<span class="sd"> ----------------------------</span>
<span class="sd"> [a b c d e f]</span>
<span class="sd"> [a b c d e f]</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>
@@ -614,14 +616,15 @@
<div class="viewcode-block" id="shunt"><a class="viewcode-back" href="../../library.html#joy.library.shunt">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">shunt</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Like concat but reverses the top list into the second.</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Like concat but reverses the top list into the second.</span>
<span class="sd"> ::</span>
<span class="sd"> shunt == [swons] step == reverse swap concat</span>
<span class="sd"> [a b c] [d e f] shunt</span>
<span class="sd"> [a b c] [d e f] shunt</span>
<span class="sd"> ---------------------------</span>
<span class="sd"> [f e d a b c] </span>
<span class="sd"> [f e d a b c] </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">stack</span>
@@ -669,9 +672,9 @@
<span class="sd"> Plus or minus</span>
<span class="sd"> ::</span>
<span class="sd"> a b pm</span>
<span class="sd"> a b pm</span>
<span class="sd"> -------------</span>
<span class="sd"> a+b a-b</span>
<span class="sd"> a+b a-b</span>
<span class="sd"> &#39;&#39;&#39;</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>
@@ -844,9 +847,9 @@
<span class="sd"> onto the pending expression for evaluation.</span>
<span class="sd"> ::</span>
<span class="sd"> [Q] i</span>
<span class="sd"> [Q] i</span>
<span class="sd"> -----------</span>
<span class="sd"> Q</span>
<span class="sd"> Q</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">quote</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
@@ -913,9 +916,9 @@
<span class="sd"> with the list as its stack. Does not affect the rest of the stack.</span>
<span class="sd"> ::</span>
<span class="sd"> ... [a b c] [Q] . infra</span>
<span class="sd"> ... [a b c] [Q] . infra</span>
<span class="sd"> -----------------------------</span>
<span class="sd"> c b a . Q [...] swaack</span>
<span class="sd"> c b a . Q [...] swaack</span>
<span class="sd"> &#39;&#39;&#39;</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">stack</span>
@@ -952,12 +955,12 @@
<span class="sd"> For example, given a (general recursive) function &#39;F&#39;:</span>
<span class="sd"> ::</span>
<span class="sd"> F == [I] [T] [R1] [R2] genrec</span>
<span class="sd"> F == [I] [T] [R1] [R2] genrec</span>
<span class="sd"> If the [I] if-part fails you must derive R1 and R2 from:</span>
<span class="sd"> ::</span>
<span class="sd"> ... R1 [F] R2</span>
<span class="sd"> ... R1 [F] R2</span>
<span class="sd"> Just set the stack arguments in front, and figure out what R1 and R2</span>
<span class="sd"> have to do to apply the quoted [F] in the proper way. In effect, the</span>
@@ -965,15 +968,15 @@
<span class="sd"> the original definition in the else-part:</span>
<span class="sd"> ::</span>
<span class="sd"> F == [I] [T] [R1] [R2] genrec</span>
<span class="sd"> == [I] [T] [R1 [F] R2] ifte</span>
<span class="sd"> F == [I] [T] [R1] [R2] genrec</span>
<span class="sd"> == [I] [T] [R1 [F] R2] ifte</span>
<span class="sd"> Primitive recursive functions are those where R2 == i.</span>
<span class="sd"> ::</span>
<span class="sd"> P == [I] [T] [R] tailrec</span>
<span class="sd"> == [I] [T] [R [P] i] ifte</span>
<span class="sd"> == [I] [T] [R P] ifte</span>
<span class="sd"> P == [I] [T] [R] tailrec</span>
<span class="sd"> == [I] [T] [R [P] i] ifte</span>
<span class="sd"> == [I] [T] [R P] ifte</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">rec2</span><span class="p">,</span> <span class="p">(</span><span class="n">rec1</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1018,9 +1021,9 @@
<span class="sd"> the data parameter is zero, then the first quotation has to produce</span>
<span class="sd"> the value to be returned. If the data parameter is positive then the</span>
<span class="sd"> second has to combine the data parameter with the result of applying</span>
<span class="sd"> the function to its predecessor.</span>
<span class="sd"> the function to its predecessor.::</span>
<span class="sd"> 5 [1] [*] primrec</span>
<span class="sd"> 5 [1] [*] primrec</span>
<span class="sd"> &gt; Then primrec tests whether the top element on the stack (initially</span>
<span class="sd"> the 5) is equal to zero. If it is, it pops it off and executes one of</span>
@@ -1028,17 +1031,17 @@
<span class="sd"> Otherwise it pushes a decremented copy of the top element and</span>
<span class="sd"> recurses. On the way back from the recursion it uses the other</span>
<span class="sd"> quotation, [*], to multiply what is now a factorial on top of the</span>
<span class="sd"> stack by the second element on the stack.</span>
<span class="sd"> stack by the second element on the stack.::</span>
<span class="sd"> n [Base] [Recur] primrec</span>
<span class="sd"> 0 [Base] [Recur] primrec</span>
<span class="sd"> ------------------------------</span>
<span class="sd"> Base</span>
<span class="sd"> 0 [Base] [Recur] primrec</span>
<span class="sd"> ------------------------------</span>
<span class="sd"> Base</span>
<span class="sd"> n [Base] [Recur] primrec</span>
<span class="sd"> ------------------------------------------ n &gt; 0</span>
<span class="sd"> n (n-1) [Base] [Recur] primrec Recur</span>
<span class="sd"> n [Base] [Recur] primrec</span>
<span class="sd"> ------------------------------------------ n &gt; 0</span>
<span class="sd"> n (n-1) [Base] [Recur] primrec Recur</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">recur</span><span class="p">,</span> <span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1072,17 +1075,17 @@
<span class="sd"> ::</span>
<span class="sd"> branch == roll&lt; choice i</span>
<span class="sd"> branch == roll&lt; choice i</span>
<span class="sd"> ::</span>
<span class="sd"> False [F] [T] branch</span>
<span class="sd"> --------------------------</span>
<span class="sd"> F</span>
<span class="sd"> False [F] [T] branch</span>
<span class="sd"> --------------------------</span>
<span class="sd"> F</span>
<span class="sd"> True [F] [T] branch</span>
<span class="sd"> -------------------------</span>
<span class="sd"> T</span>
<span class="sd"> True [F] [T] branch</span>
<span class="sd"> -------------------------</span>
<span class="sd"> T</span>
<span class="sd"> &#39;&#39;&#39;</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>
@@ -1129,9 +1132,9 @@
<span class="sd"> It works by rewriting into a chain of nested `ifte` expressions, e.g.::</span>
<span class="sd"> [[[B0] T0] [[B1] T1] [D]] cond</span>
<span class="sd"> -----------------------------------------</span>
<span class="sd"> [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
<span class="sd"> [[[B0] T0] [[B1] T1] [D]] cond</span>
<span class="sd"> -----------------------------------------</span>
<span class="sd"> [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">conditions</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1166,9 +1169,9 @@
<span class="sd"> on the rest of the stack.</span>
<span class="sd"> ::</span>
<span class="sd"> ... x [Q] dip</span>
<span class="sd"> ... x [Q] dip</span>
<span class="sd"> -------------------</span>
<span class="sd"> ... Q x</span>
<span class="sd"> ... Q x</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1183,9 +1186,9 @@
<span class="sd"> Like dip but expects two items.</span>
<span class="sd"> ::</span>
<span class="sd"> ... y x [Q] dip</span>
<span class="sd"> ... y x [Q] dip</span>
<span class="sd"> ---------------------</span>
<span class="sd"> ... Q y x</span>
<span class="sd"> ... Q y x</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">S</span>
@@ -1200,9 +1203,9 @@
<span class="sd"> Like dip but expects three items.</span>
<span class="sd"> ::</span>
<span class="sd"> ... z y x [Q] dip</span>
<span class="sd"> ... z y x [Q] dip</span>
<span class="sd"> -----------------------</span>
<span class="sd"> ... Q z y x</span>
<span class="sd"> ... Q z y x</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">S</span>
@@ -1219,9 +1222,10 @@
<span class="sd"> program.</span>
<span class="sd"> ::</span>
<span class="sd"> ... x [Q] . app1</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [x ...] [Q] . infra first</span>
<span class="sd"> ... x [Q] . app1</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [x ...] [Q] . infra first</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">S</span>
<span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">stack</span><span class="p">))</span>
@@ -1235,10 +1239,10 @@
<span class="sd">&#39;&#39;&#39;Like app1 with two items.</span>
<span class="sd"> ::</span>
<span class="sd"> ... y x [Q] . app2</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [y ...] [Q] . infra first</span>
<span class="sd"> [x ...] [Q] infra first</span>
<span class="sd"> ... y x [Q] . app2</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [y ...] [Q] . infra first</span>
<span class="sd"> [x ...] [Q] infra first</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">S</span>
@@ -1255,11 +1259,11 @@
<span class="sd">&#39;&#39;&#39;Like app1 with three items.</span>
<span class="sd"> ::</span>
<span class="sd"> ... z y x [Q] . app3</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [z ...] [Q] . infra first</span>
<span class="sd"> [y ...] [Q] infra first</span>
<span class="sd"> [x ...] [Q] infra first</span>
<span class="sd"> ... z y x [Q] . app3</span>
<span class="sd"> -----------------------------------</span>
<span class="sd"> ... [z ...] [Q] . infra first</span>
<span class="sd"> [y ...] [Q] infra first</span>
<span class="sd"> [x ...] [Q] infra first</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">S</span>
@@ -1278,19 +1282,19 @@
<span class="sd"> Run a quoted program on each item in a sequence.</span>
<span class="sd"> ::</span>
<span class="sd"> ... [] [Q] . step</span>
<span class="sd"> -----------------------</span>
<span class="sd"> ... .</span>
<span class="sd"> ... [] [Q] . step</span>
<span class="sd"> -----------------------</span>
<span class="sd"> ... .</span>
<span class="sd"> ... [a] [Q] . step</span>
<span class="sd"> ------------------------</span>
<span class="sd"> ... a . Q</span>
<span class="sd"> ... [a] [Q] . step</span>
<span class="sd"> ------------------------</span>
<span class="sd"> ... a . Q</span>
<span class="sd"> ... [a b c] [Q] . step</span>
<span class="sd"> ... [a b c] [Q] . step</span>
<span class="sd"> ----------------------------------------</span>
<span class="sd"> ... a . Q [b c] [Q] step</span>
<span class="sd"> ... a . Q [b c] [Q] step</span>
<span class="sd"> The step combinator executes the quotation on each member of the list</span>
<span class="sd"> on top of the stack.</span>
@@ -1313,19 +1317,19 @@
<span class="sd"> times == [-- dip] cons [swap] infra [0 &gt;] swap while pop</span>
<span class="sd"> ::</span>
<span class="sd"> ... n [Q] . times</span>
<span class="sd"> ... n [Q] . times</span>
<span class="sd"> --------------------- w/ n &lt;= 0</span>
<span class="sd"> ... .</span>
<span class="sd"> ... .</span>
<span class="sd"> ... 1 [Q] . times</span>
<span class="sd"> ---------------------------------</span>
<span class="sd"> ... . Q</span>
<span class="sd"> ... 1 [Q] . times</span>
<span class="sd"> -----------------------</span>
<span class="sd"> ... . Q</span>
<span class="sd"> ... n [Q] . times</span>
<span class="sd"> --------------------------------- w/ n &gt; 1</span>
<span class="sd"> ... . Q (n - 1) [Q] times</span>
<span class="sd"> ... n [Q] . times</span>
<span class="sd"> ------------------------------------- w/ n &gt; 1</span>
<span class="sd"> ... . Q (n - 1) [Q] times</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># times == [-- dip] cons [swap] infra [0 &gt;] swap while pop</span>
@@ -1362,13 +1366,13 @@
<span class="sd"> Basic loop combinator.</span>
<span class="sd"> ::</span>
<span class="sd"> ... True [Q] loop</span>
<span class="sd"> ... True [Q] loop</span>
<span class="sd"> -----------------------</span>
<span class="sd"> ... Q [Q] loop</span>
<span class="sd"> ... Q [Q] loop</span>
<span class="sd"> ... False [Q] loop</span>
<span class="sd"> ... False [Q] loop</span>
<span class="sd"> ------------------------</span>
<span class="sd"> ...</span>
<span class="sd"> ...</span>
<span class="sd"> &#39;&#39;&#39;</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>
@@ -1385,17 +1389,17 @@
<span class="sd"> one of the three depending on the results of comparing the two values:</span>
<span class="sd"> ::</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &gt; b</span>
<span class="sd"> G</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &gt; b</span>
<span class="sd"> G</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a = b</span>
<span class="sd"> E</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a = b</span>
<span class="sd"> E</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &lt; b</span>
<span class="sd"> L</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &lt; b</span>
<span class="sd"> L</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">L</span><span class="p">,</span> <span class="p">(</span><span class="n">E</span><span class="p">,</span> <span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">concat</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html
+12 -13
View File
@@ -53,22 +53,21 @@
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd">Pretty printing support, e.g.::</span>
<span class="sd"> Joy? 23 18 * 99 +</span>
<span class="sd"> . 23 18 mul 99 add</span>
<span class="sd"> 23 . 18 mul 99 add</span>
<span class="sd"> 23 18 . mul 99 add</span>
<span class="sd"> 414 . 99 add</span>
<span class="sd"> 414 99 . add</span>
<span class="sd"> 513 . </span>
<span class="sd"> Joy? [23 18 * 99 +] trace</span>
<span class="sd"> • 23 18 mul 99 add</span>
<span class="sd"> 23 • 18 mul 99 add</span>
<span class="sd"> 23 18 • mul 99 add</span>
<span class="sd"> 414 • 99 add</span>
<span class="sd"> 414 99 • add</span>
<span class="sd"> 513 • </span>
<span class="sd"> 513 &lt;-top</span>
<span class="sd"> joy? </span>
<span class="sd">On each line the stack is printed with the top to the right, then a ``.`` to</span>
<span class="sd">represent the current locus of processing, then the pending expression to the</span>
<span class="sd">left.</span>
<span class="sd">On each line the stack is printed with the top to the left, then a</span>
<span class="sd">bullet symbol,``•``, to represent the current locus of processing, then</span>
<span class="sd">the pending expression to the right.</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="c1"># (Kinda clunky and hacky. This should be swapped out in favor of much</span>
<span class="c1"># smarter stuff.)</span>
@@ -147,8 +146,8 @@
<span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="n">max_stack_length</span><span class="p">:</span>
<span class="n">max_stack_length</span> <span class="o">=</span> <span class="n">n</span>
<span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> . </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</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="k">return</span> <span class="p">[</span> <span class="c1"># Prefix spaces to line up &#39;.&#39;s.</span>
<span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> • </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</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="k">return</span> <span class="p">[</span> <span class="c1"># Prefix spaces to line up &#39;•&#39;s.</span>
<span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="o">*</span> <span class="p">(</span><span class="n">max_stack_length</span> <span class="o">-</span> <span class="n">length</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">)</span>
<span class="k">for</span> <span class="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span>
<span class="p">]</span></div>
docs/sphinx_docs/_build/html/library.html
+93 -92
View File
@@ -104,9 +104,9 @@ if it’s in the dict. Aliases for functions not in the dict are ignored.</p>
<dd><p>Given a quoted program on TOS and anything as the second stack item run
the program and replace the two args with the first result of the
program.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@@ -115,10 +115,10 @@ program.</p>
<dt id="joy.library.app2">
<code class="descclassname">joy.library.</code><code class="descname">app2</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app2"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app2" title="Permalink to this definition"></a></dt>
<dd><p>Like app1 with two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@@ -127,11 +127,11 @@ program.</p>
<dt id="joy.library.app3">
<code class="descclassname">joy.library.</code><code class="descname">app3</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app3"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app3" title="Permalink to this definition"></a></dt>
<dd><p>Like app1 with three items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@@ -154,13 +154,13 @@ program.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">branch</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="n">choice</span> <span class="n">i</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="o">--------------------------</span>
<span class="n">F</span>
<span class="n">F</span>
<span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="o">-------------------------</span>
<span class="n">T</span>
<span class="n">T</span>
</pre></div>
</div>
</dd></dl>
@@ -169,14 +169,14 @@ program.</p>
<dt id="joy.library.choice">
<code class="descclassname">joy.library.</code><code class="descname">choice</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#choice"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.choice" title="Permalink to this definition"></a></dt>
<dd><p>Use a Boolean value to select one of two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
<span class="o">----------------------</span>
<span class="n">A</span>
<span class="n">A</span>
<span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
<span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
<span class="o">---------------------</span>
<span class="n">B</span>
<span class="n">B</span>
</pre></div>
</div>
<p>Currently Python semantics are used to evaluate the “truthiness” of the
@@ -189,7 +189,7 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<dd><p>Clear everything from the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">clear</span> <span class="o">==</span> <span class="n">stack</span> <span class="p">[</span><span class="n">pop</span> <span class="n">stack</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="n">clear</span>
<span class="o">...</span> <span class="n">clear</span>
<span class="o">---------------</span>
</pre></div>
</div>
@@ -200,17 +200,17 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<code class="descclassname">joy.library.</code><code class="descname">cmp_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cmp_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cmp_" title="Permalink to this definition"></a></dt>
<dd><p>cmp takes two values and three quoted programs on the stack and runs
one of the three depending on the results of comparing the two values:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span>
<span class="n">G</span>
<span class="n">G</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
<span class="n">E</span>
<span class="n">E</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span>
<span class="n">L</span>
<span class="n">L</span>
</pre></div>
</div>
</dd></dl>
@@ -219,9 +219,9 @@ one of the three depending on the results of comparing the two values:</p>
<dt id="joy.library.concat_">
<code class="descclassname">joy.library.</code><code class="descname">concat_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#concat_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.concat_" title="Permalink to this definition"></a></dt>
<dd><p>Concatinate the two lists on the top of the stack.</p>
<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="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
<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="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
<span class="o">----------------------------</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="n">e</span> <span class="n">f</span><span class="p">]</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="n">e</span> <span class="n">f</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@@ -235,9 +235,9 @@ default quote. Each condition clause should contain a quoted predicate
followed by the function expression to run if that predicate returns
true. If no predicates return true the default function runs.</p>
<p>It works by rewriting into a chain of nested <cite>ifte</cite> expressions, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
<span class="o">-----------------------------------------</span>
<span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
<span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div>
</div>
</dd></dl>
@@ -248,9 +248,9 @@ true. If no predicates return true the default function runs.</p>
<dd><p>The dip combinator expects a quoted program on the stack and below it
some item, it hoists the item into the expression and runs the program
on the rest of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">-------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@@ -259,9 +259,9 @@ on the rest of the stack.</p>
<dt id="joy.library.dipd">
<code class="descclassname">joy.library.</code><code class="descname">dipd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipd" title="Permalink to this definition"></a></dt>
<dd><p>Like dip but expects two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">---------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@@ -270,9 +270,9 @@ on the rest of the stack.</p>
<dt id="joy.library.dipdd">
<code class="descclassname">joy.library.</code><code class="descname">dipdd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipdd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipdd" title="Permalink to this definition"></a></dt>
<dd><p>Like dip but expects three items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@@ -299,9 +299,9 @@ the stack discarding the rest of the stack.</p>
</div>
<p>Expects an integer and a quote on the stack and returns the quote with
n items removed off the top.</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">drop</span>
<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">drop</span>
<span class="o">----------------------</span>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@@ -381,9 +381,9 @@ the original definition in the else-part:</p>
</div>
<p>Expects an integer and a quote on the stack and returns the item at the
nth position in the quote counting from 0.</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">0</span> <span class="n">getitem</span>
<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">0</span> <span class="n">getitem</span>
<span class="o">-------------------------</span>
<span class="n">a</span>
<span class="n">a</span>
</pre></div>
</div>
</dd></dl>
@@ -399,9 +399,9 @@ nth position in the quote counting from 0.</p>
<code class="descclassname">joy.library.</code><code class="descname">i</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#i"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.i" title="Permalink to this definition"></a></dt>
<dd><p>The i combinator expects a quoted program on the stack and unpacks it
onto the pending expression for evaluation.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
<span class="o">-----------</span>
<span class="n">Q</span>
<span class="n">Q</span>
</pre></div>
</div>
</dd></dl>
@@ -417,9 +417,9 @@ onto the pending expression for evaluation.</p>
<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>
<dd><p>Accept a quoted program and a list on the stack and run the program
with the list as its stack. Does not affect the rest of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
<span class="o">-----------------------------</span>
<span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
<span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
</pre></div>
</div>
</dd></dl>
@@ -452,13 +452,13 @@ the definitions.txt resource.</p>
<dt id="joy.library.loop">
<code class="descclassname">joy.library.</code><code class="descname">loop</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#loop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.loop" title="Permalink to this definition"></a></dt>
<dd><p>Basic loop combinator.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">------------------------</span>
<span class="o">...</span>
<span class="o">...</span>
</pre></div>
</div>
</dd></dl>
@@ -492,9 +492,9 @@ new list with the results in place of the program and original list.</p>
<dt id="joy.library.pm">
<code class="descclassname">joy.library.</code><code class="descname">pm</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#pm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pm" title="Permalink to this definition"></a></dt>
<dd><p>Plus or minus</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
<span class="o">-------------</span>
<span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
<span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
</pre></div>
</div>
</dd></dl>
@@ -514,29 +514,28 @@ data parameter. For an integer data parameter it works like this: If
the data parameter is zero, then the first quotation has to produce
the value to be returned. If the data parameter is positive then the
second has to combine the data parameter with the result of applying
the function to its predecessor.</p>
<p>5 [1] [*] primrec</p>
the function to its predecessor.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">5</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="o">*</span><span class="p">]</span> <span class="n">primrec</span>
</pre></div>
</div>
<p>&gt; Then primrec tests whether the top element on the stack (initially
the 5) is equal to zero. If it is, it pops it off and executes one of
the quotations, the [1] which leaves 1 on the stack as the result.
Otherwise it pushes a decremented copy of the top element and
recurses. On the way back from the recursion it uses the other
quotation, [*], to multiply what is now a factorial on top of the
stack by the second element on the stack.</p>
<blockquote>
<div><blockquote>
<div>n [Base] [Recur] primrec</div></blockquote>
<p>0 [Base] [Recur] primrec</p>
</div></blockquote>
<blockquote>
<div><blockquote>
<div>Base</div></blockquote>
<p>n [Base] [Recur] primrec</p>
</div></blockquote>
<dl class="docutils">
<dt>—————————————— n &gt; 0</dt>
<dd>n (n-1) [Base] [Recur] primrec Recur</dd>
</dl>
stack by the second element on the stack.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="p">[</span><span class="n">Base</span><span class="p">]</span> <span class="p">[</span><span class="n">Recur</span><span class="p">]</span> <span class="n">primrec</span>
<span class="mi">0</span> <span class="p">[</span><span class="n">Base</span><span class="p">]</span> <span class="p">[</span><span class="n">Recur</span><span class="p">]</span> <span class="n">primrec</span>
<span class="o">------------------------------</span>
<span class="n">Base</span>
<span class="n">n</span> <span class="p">[</span><span class="n">Base</span><span class="p">]</span> <span class="p">[</span><span class="n">Recur</span><span class="p">]</span> <span class="n">primrec</span>
<span class="o">------------------------------------------</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">0</span>
<span class="n">n</span> <span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Base</span><span class="p">]</span> <span class="p">[</span><span class="n">Recur</span><span class="p">]</span> <span class="n">primrec</span> <span class="n">Recur</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -544,9 +543,9 @@ stack by the second element on the stack.</p>
<code class="descclassname">joy.library.</code><code class="descname">remove</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#remove"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.remove" title="Permalink to this definition"></a></dt>
<dd><p>Expects an item on the stack and a quote under it and removes that item
from the the quote. The item is only removed once.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
<span class="o">------------------------</span>
<span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@@ -564,14 +563,14 @@ from the the quote. The item is only removed once.</p>
<dt id="joy.library.select">
<code class="descclassname">joy.library.</code><code class="descname">select</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#select"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.select" title="Permalink to this definition"></a></dt>
<dd><p>Use a Boolean value to select one of two items from a sequence.</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="p">]</span> <span class="kc">False</span> <span class="n">select</span>
<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="p">]</span> <span class="kc">False</span> <span class="n">select</span>
<span class="o">------------------------</span>
<span class="n">A</span>
<span class="n">A</span>
<span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
<span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
<span class="o">-----------------------</span>
<span class="n">B</span>
<span class="n">B</span>
</pre></div>
</div>
<p>The sequence can contain more than two items but not fewer.
@@ -591,9 +590,9 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<dd><p>Like concat but reverses the top list into the second.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">shunt</span> <span class="o">==</span> <span class="p">[</span><span class="n">swons</span><span class="p">]</span> <span class="n">step</span> <span class="o">==</span> <span class="n">reverse</span> <span class="n">swap</span> <span class="n">concat</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
<span class="o">---------------------------</span>
<span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span>
<span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@@ -615,19 +614,19 @@ Negative numbers return complex roots.</p>
<dt id="joy.library.step">
<code class="descclassname">joy.library.</code><code class="descname">step</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#step"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.step" title="Permalink to this definition"></a></dt>
<dd><p>Run a quoted program on each item in a sequence.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="o">.</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">----------------------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
</pre></div>
</div>
<p>The step combinator executes the quotation on each member of the list
@@ -644,7 +643,9 @@ on top of the stack.</p>
<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>
<p>sum == 0 swap [+] step</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">step</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -653,9 +654,9 @@ on top of the stack.</p>
<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>
<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>
<span class="o">----------------------</span>
<span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
<span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@@ -664,19 +665,19 @@ use reverse if needed.)</p>
<dt id="joy.library.times">
<code class="descclassname">joy.library.</code><code class="descname">times</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#times"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.times" title="Permalink to this definition"></a></dt>
<dd><p>times == [– dip] cons [swap] infra [0 &gt;] swap while pop</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">0</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------------------</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">1</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
<span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">-------------------------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">1</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
</pre></div>
</div>
</dd></dl>
docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html
+16 -16
View File
@@ -32,13 +32,13 @@
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="newtons-method">
<h1><a class="reference external" href="https://en.wikipedia.org/wiki/Newton%27s_method">Newton’s method</a><a class="headerlink" href="#newtons-method" title="Permalink to this headline"></a></h1>
<div class="section" id="newton-s-method">
<h1><a class="reference external" href="https://en.wikipedia.org/wiki/Newton%27s_method">Newton’s method</a><a class="headerlink" href="#newton-s-method" title="Permalink to this headline"></a></h1>
<p>Let’s use the Newton-Raphson method for finding the root of an equation
to write a function that can compute the square root of a number.</p>
<p>Cf. <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why Functional Programming Matters” by John
Hughes</a></p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span><span class="p">,</span> <span class="n">define</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span><span class="p">,</span> <span class="n">define</span>
</pre></div>
</div>
<div class="section" id="a-generator-for-approximations">
@@ -90,10 +90,10 @@ function we’re writing. If we let 1 be the initial approximation:</p>
<span class="mi">1</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">make_generator</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;gsra == 1 swap [over / + 2 /] cons [dup] swoncat make_generator&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;gsra 1 swap [over / + 2 /] cons [dup] swoncat make_generator&#39;</span><span class="p">)</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 gsra&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 gsra&#39;</span><span class="p">)</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">1</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">codireco</span><span class="p">]</span>
@@ -101,7 +101,7 @@ function we’re writing. If we let 1 be the initial approximation:</p>
</div>
<p>Let’s drive the generator a few time (with the <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator) and
square the approximation to see how well it works…</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 gsra 6 [x popd] times first sqr&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 gsra 6 [x popd] times first sqr&#39;</span><span class="p">)</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">23.0000000001585</span>
@@ -142,7 +142,7 @@ generated already and epsilon ε is handy on the stack…</p>
<span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="o">-</span><span class="n">b</span><span class="p">)</span><span class="o">&lt;=</span><span class="n">ε</span><span class="p">)</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_P == [first - abs] dip &lt;=&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_P [first - abs] dip &lt;=&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
@@ -154,7 +154,7 @@ generated already and epsilon ε is handy on the stack…</p>
<span class="n">b</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_B == roll&lt; popop first&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_B roll&lt; popop first&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
@@ -166,7 +166,7 @@ generated already and epsilon ε is handy on the stack…</p>
<ol class="arabic simple">
<li>Discard a.</li>
<li>Use <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator to generate next term from <code class="docutils literal notranslate"><span class="pre">G</span></code>.</li>
<li>Run <code class="docutils literal notranslate"><span class="pre">within</span></code> with <code class="docutils literal notranslate"><span class="pre">i</span></code> (it is a <code class="docutils literal notranslate"><span class="pre">primrec</span></code> function.)</li>
<li>Run <code class="docutils literal notranslate"><span class="pre">within</span></code> with <code class="docutils literal notranslate"><span class="pre">i</span></code> (it is a “tail-recursive” function.)</li>
</ol>
<p>Pretty straightforward:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">R0</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">R1</span>
@@ -179,7 +179,7 @@ generated already and epsilon ε is handy on the stack…</p>
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_R == [popd x] dip&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;_within_R [popd x] dip&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
@@ -191,31 +191,31 @@ generated already and epsilon ε is handy on the stack…</p>
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="o">...</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;within == x 0.000000001 [_within_P] [_within_B] [_within_R] primrec&#39;</span><span class="p">)</span>
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;sqrt == gsra within&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;within x 0.000000001 [_within_P] [_within_B] [_within_R] tailrec&#39;</span><span class="p">)</span>
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;sqrt gsra within&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>Try it out…</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;36 sqrt&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;36 sqrt&#39;</span><span class="p">)</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">6.0</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 sqrt&#39;</span><span class="p">)</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;23 sqrt&#39;</span><span class="p">)</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span>
</pre></div>
</div>
<p>Check it.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span><span class="o">**</span><span class="mi">2</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span><span class="o">**</span><span class="mi">2</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">22.999999999999996</span>
</pre></div>
</div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">math</span> <span class="k">import</span> <span class="n">sqrt</span>
<div class="code ipython3 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">math</span> <span class="k">import</span> <span class="n">sqrt</span>
<span class="n">sqrt</span><span class="p">(</span><span class="mi">23</span><span class="p">)</span>
</pre></div>
docs/sphinx_docs/_build/html/pretty.html
+10 -10
View File
@@ -37,22 +37,22 @@
<div class="section" id="module-joy.utils.pretty_print">
<span id="joy-utils-pretty-print"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.utils.pretty_print</span></code><a class="headerlink" href="#module-joy.utils.pretty_print" title="Permalink to this headline"></a></h2>
<p>Pretty printing support, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Joy? 23 18 * 99 +
. 23 18 mul 99 add
23 . 18 mul 99 add
23 18 . mul 99 add
414 . 99 add
414 99 . add
513 .
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Joy? [23 18 * 99 +] trace
• 23 18 mul 99 add
23 • 18 mul 99 add
23 18 • mul 99 add
414 • 99 add
414 99 • add
513 •
513 &lt;-top
joy?
</pre></div>
</div>
<p>On each line the stack is printed with the top to the right, then a <code class="docutils literal notranslate"><span class="pre">.</span></code> to
represent the current locus of processing, then the pending expression to the
left.</p>
<p>On each line the stack is printed with the top to the left, then a
bullet symbol,``•<a href="#id1"><span class="problematic" id="id2">``</span></a>, to represent the current locus of processing, then
the pending expression to the right.</p>
<dl class="class">
<dt id="joy.utils.pretty_print.TracePrinter">
<em class="property">class </em><code class="descclassname">joy.utils.pretty_print.</code><code class="descname">TracePrinter</code><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter" title="Permalink to this definition"></a></dt>
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/notebooks/Newton-Raphson.rst
+76 -76
View File
@@ -1,13 +1,13 @@
`Newton’s method <https://en.wikipedia.org/wiki/Newton%27s_method>`__
`Newton's method <https://en.wikipedia.org/wiki/Newton%27s_method>`__
=====================================================================
Let’s use the Newton-Raphson method for finding the root of an equation
Let's use the Newton-Raphson method for finding the root of an equation
to write a function that can compute the square root of a number.
Cf. `“Why Functional Programming Matters” by John
Cf. `"Why Functional Programming Matters" by John
Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__
.. code:: ipython2
.. code:: ipython3
from notebook_preamble import J, V, define
@@ -20,9 +20,9 @@ computes the next approximation:
::
a F
---------
a'
a F
---------
a'
A Function to Compute the Next Approximation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -34,17 +34,17 @@ square root:
::
a n over / + 2 /
a n a / + 2 /
a n/a + 2 /
a+n/a 2 /
(a+n/a)/2
a n over / + 2 /
a n a / + 2 /
a n/a + 2 /
a+n/a 2 /
(a+n/a)/2
The function we want has the argument ``n`` in it:
::
F == n over / + 2 /
F == n over / + 2 /
Make it into a Generator
~~~~~~~~~~~~~~~~~~~~~~~~
@@ -53,33 +53,33 @@ Our generator would be created by:
::
a [dup F] make_generator
a [dup F] make_generator
With n as part of the function F, but n is the input to the sqrt
function we’re writing. If we let 1 be the initial approximation:
::
1 n 1 / + 2 /
1 n/1 + 2 /
1 n + 2 /
n+1 2 /
(n+1)/2
1 n 1 / + 2 /
1 n/1 + 2 /
1 n + 2 /
n+1 2 /
(n+1)/2
The generator can be written as:
::
23 1 swap [over / + 2 /] cons [dup] swoncat make_generator
1 23 [over / + 2 /] cons [dup] swoncat make_generator
1 [23 over / + 2 /] [dup] swoncat make_generator
1 [dup 23 over / + 2 /] make_generator
23 1 swap [over / + 2 /] cons [dup] swoncat make_generator
1 23 [over / + 2 /] cons [dup] swoncat make_generator
1 [23 over / + 2 /] [dup] swoncat make_generator
1 [dup 23 over / + 2 /] make_generator
.. code:: ipython2
.. code:: ipython3
define('gsra == 1 swap [over / + 2 /] cons [dup] swoncat make_generator')
define('gsra 1 swap [over / + 2 /] cons [dup] swoncat make_generator')
.. code:: ipython2
.. code:: ipython3
J('23 gsra')
@@ -89,10 +89,10 @@ The generator can be written as:
[1 [dup 23 over / + 2 /] codireco]
Let’s drive the generator a few time (with the ``x`` combinator) and
square the approximation to see how well it works…
Let's drive the generator a few time (with the ``x`` combinator) and
square the approximation to see how well it works...
.. code:: ipython2
.. code:: ipython3
J('23 gsra 6 [x popd] times first sqr')
@@ -105,88 +105,88 @@ square the approximation to see how well it works…
Finding Consecutive Approximations within a Tolerance
-----------------------------------------------------
From `“Why Functional Programming Matters” by John
From `"Why Functional Programming Matters" by John
Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__:
The remainder of a square root finder is a function *within*, which
takes a tolerance and a list of approximations and looks down the
list for two successive approximations that differ by no more than
the given tolerance.
The remainder of a square root finder is a function *within*, which
takes a tolerance and a list of approximations and looks down the
list for two successive approximations that differ by no more than
the given tolerance.
(And note that by “list” he means a lazily-evaluated list.)
Using the *output* ``[a G]`` of the above generator for square root
approximations, and further assuming that the first term a has been
generated already and epsilon ε is handy on the stack…
generated already and epsilon ε is handy on the stack...
::
a [b G] ε within
---------------------- a b - abs ε <=
b
a [b G] ε within
---------------------- a b - abs ε <=
b
a [b G] ε within
---------------------- a b - abs ε >
b [c G] ε within
a [b G] ε within
---------------------- a b - abs ε >
b [c G] ε within
Predicate
~~~~~~~~~
::
a [b G] ε [first - abs] dip <=
a [b G] first - abs ε <=
a b - abs ε <=
a-b abs ε <=
abs(a-b) ε <=
(abs(a-b)<=ε)
a [b G] ε [first - abs] dip <=
a [b G] first - abs ε <=
a b - abs ε <=
a-b abs ε <=
abs(a-b) ε <=
(abs(a-b)<=ε)
.. code:: ipython2
.. code:: ipython3
define('_within_P == [first - abs] dip <=')
define('_within_P [first - abs] dip <=')
Base-Case
~~~~~~~~~
::
a [b G] ε roll< popop first
[b G] ε a popop first
[b G] first
b
a [b G] ε roll< popop first
[b G] ε a popop first
[b G] first
b
.. code:: ipython2
.. code:: ipython3
define('_within_B == roll< popop first')
define('_within_B roll< popop first')
Recur
~~~~~
::
a [b G] ε R0 [within] R1
a [b G] ε R0 [within] R1
1. Discard a.
2. Use ``x`` combinator to generate next term from ``G``.
3. Run ``within`` with ``i`` (it is a ``primrec`` function.)
3. Run ``within`` with ``i`` (it is a "tail-recursive" function.)
Pretty straightforward:
::
a [b G] ε R0 [within] R1
a [b G] ε [popd x] dip [within] i
a [b G] popd x ε [within] i
[b G] x ε [within] i
b [c G] ε [within] i
b [c G] ε within
a [b G] ε R0 [within] R1
a [b G] ε [popd x] dip [within] i
a [b G] popd x ε [within] i
[b G] x ε [within] i
b [c G] ε [within] i
b [c G] ε within
b [c G] ε within
b [c G] ε within
.. code:: ipython2
.. code:: ipython3
define('_within_R == [popd x] dip')
define('_within_R [popd x] dip')
Setting up
~~~~~~~~~~
@@ -196,17 +196,17 @@ The recursive function we have defined so far needs a slight preamble:
::
[a G] x ε ...
a [b G] ε ...
[a G] x ε ...
a [b G] ε ...
.. code:: ipython2
.. code:: ipython3
define('within == x 0.000000001 [_within_P] [_within_B] [_within_R] primrec')
define('sqrt == gsra within')
define('within x 0.000000001 [_within_P] [_within_B] [_within_R] tailrec')
define('sqrt gsra within')
Try it out…
Try it out...
.. code:: ipython2
.. code:: ipython3
J('36 sqrt')
@@ -216,7 +216,7 @@ Try it out…
6.0
.. code:: ipython2
.. code:: ipython3
J('23 sqrt')
@@ -228,7 +228,7 @@ Try it out…
Check it.
.. code:: ipython2
.. code:: ipython3
4.795831523312719**2
@@ -241,7 +241,7 @@ Check it.
.. code:: ipython2
.. code:: ipython3
from math import sqrt