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

Rebuild HTML docs.

Browse Source
This commit is contained in:
Simon Forman
2022-08-16 15:26:07 -07:00
parent f70a941be3
commit 4a5716d8b2
23 changed files with 139 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/sphinx_docs/_build/doctrees/environment.pickle
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/joy.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/lib.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/library.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/notebooks/The_Four_Operations.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/parser.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/doctrees/stack.doctree
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/html/_modules/joy/joy.html
+11 -10
View File
@@ -58,9 +58,9 @@
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="kn">import</span> <span class="nb">input</span> <span class="kn">from</span> <span class="nn">builtins</span> <span class="kn">import</span> <span class="nb">input</span>
<span class="kn">from</span> <span class="nn">traceback</span> <span class="kn">import</span> <span class="n">print_exc</span> <span class="kn">from</span> <span class="nn">traceback</span> <span class="kn">import</span> <span class="n">print_exc</span>
<span class="kn">from</span> <span class="nn">.parser</span> <span class="kn">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">joy.parser</span> <span class="kn">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="kn">import</span> <span class="n">stack_to_string</span> <span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="kn">import</span> <span class="n">stack_to_string</span>
<span class="kn">from</span> <span class="nn">.utils.errors</span> <span class="kn">import</span> <span class="p">(</span> <span class="kn">from</span> <span class="nn">joy.utils.errors</span> <span class="kn">import</span> <span class="p">(</span>
<span class="n">NotAListError</span><span class="p">,</span> <span class="n">NotAListError</span><span class="p">,</span>
<span class="n">NotAnIntError</span><span class="p">,</span> <span class="n">NotAnIntError</span><span class="p">,</span>
<span class="n">StackUnderflowError</span><span class="p">,</span> <span class="n">StackUnderflowError</span><span class="p">,</span>
@@ -71,12 +71,13 @@
<div class="viewcode-block" id="joy"><a class="viewcode-back" href="../../joy.html#joy.joy.joy">[docs]</a><span class="k">def</span> <span class="nf">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <div class="viewcode-block" id="joy"><a class="viewcode-back" href="../../joy.html#joy.joy.joy">[docs]</a><span class="k">def</span> <span class="nf">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a stack.</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Evaluate a Joy expression on a stack.</span>
<span class="sd"> This function iterates through a sequence of terms which are either</span> <span class="sd"> This function iterates through a sequence of terms which are either</span>
<span class="sd"> literals (strings, numbers, sequences of terms) or function symbols.</span> <span class="sd"> literals (strings, numbers, sequences of terms) or function symbols.</span>
<span class="sd"> Literals are put onto the stack and functions are looked up in the</span> <span class="sd"> Literals are put onto the stack and functions are looked up in the</span>
<span class="sd"> dictionary and executed.</span> <span class="sd"> dictionary and executed.</span>
<span class="sd"> The viewer is a function that is called with the stack and expression</span> <span class="sd"> The viewer is a function that is called with the stack and expression</span>
<span class="sd"> on every iteration, its return value is ignored.</span> <span class="sd"> on every iteration, its return value is ignored.</span>
@@ -173,7 +174,7 @@
<span class="k">except</span> <span class="n">NotAnIntError</span><span class="p">:</span> <span class="k">except</span> <span class="n">NotAnIntError</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Not an integer.&#39;</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Not an integer.&#39;</span><span class="p">)</span>
<span class="k">except</span> <span class="n">NotAListError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span> <span class="k">except</span> <span class="n">NotAListError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="n">e</span><span class="p">)</span> <span class="c1"># &#39;Not a list.&#39;</span> <span class="nb">print</span><span class="p">(</span><span class="n">e</span><span class="p">)</span>
<span class="k">except</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="n">print_exc</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">))</span>
@@ -247,7 +248,7 @@
</a> </a>
<br /> <br />
<span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Thun Documentation</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://joypy.osdn.io/" property="cc:attributionName" rel="cc:attributionURL">Simon Forman</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct="http://purl.org/dc/terms/" href="https://osdn.net/projects/joypy/" rel="dct:source">https://osdn.net/projects/joypy/</a>. <span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Thun Documentation</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://joypy.osdn.io/" property="cc:attributionName" rel="cc:attributionURL">Simon Forman</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct="http://purl.org/dc/terms/" href="https://osdn.net/projects/joypy/" rel="dct:source">https://osdn.net/projects/joypy/</a>.
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.4.0.
</div> </div>
</body> </body>
docs/sphinx_docs/_build/html/_modules/joy/library.html
+46 -26
View File
@@ -174,9 +174,9 @@
<span class="k">return</span> <span class="n">inner</span></div> <span class="k">return</span> <span class="n">inner</span></div>
<div class="viewcode-block" id="BinaryBuiltinWrapper"><a class="viewcode-back" href="../../library.html#joy.library.BinaryBuiltinWrapper">[docs]</a><span class="k">def</span> <span class="nf">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span> <div class="viewcode-block" id="BinaryMathWrapper"><a class="viewcode-back" href="../../library.html#joy.library.BinaryMathWrapper">[docs]</a><span class="k">def</span> <span class="nf">BinaryMathWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Wrap functions that take two arguments and return a single result.</span> <span class="sd"> Wrap functions that take two numbers and return a single result.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
@@ -185,13 +185,33 @@
<span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">StackUnderflowError</span><span class="p">(</span><span class="s1">&#39;Not enough values on stack.&#39;</span><span class="p">)</span> <span class="k">raise</span> <span class="n">StackUnderflowError</span><span class="p">(</span><span class="s1">&#39;Not enough values on stack.&#39;</span><span class="p">)</span>
<span class="c1"># Boolean predicates like &quot;or&quot; fail here. :(</span> <span class="k">if</span> <span class="p">(</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="c1">## if ( not isinstance(a, int)</span> <span class="ow">or</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="c1">## or not isinstance(b, int)</span> <span class="c1"># bool is int in Python.</span>
<span class="c1">## or isinstance(a, bool) # Because bools are ints in Python.</span> <span class="ow">or</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
<span class="c1">## or isinstance(b, bool)</span> <span class="ow">or</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
<span class="p">):</span>
<span class="k">raise</span> <span class="n">NotAnIntError</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="p">)</span>
<span class="k">return</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
<span class="k">return</span> <span class="n">inner</span></div>
<div class="viewcode-block" id="BinaryLogicWrapper"><a class="viewcode-back" href="../../library.html#joy.library.BinaryLogicWrapper">[docs]</a><span class="k">def</span> <span class="nf">BinaryLogicWrapper</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Wrap functions that take two numbers and return a single result.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="nd">@FunctionWrapper</span>
<span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">inner</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span>
<span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">StackUnderflowError</span><span class="p">(</span><span class="s1">&#39;Not enough values on stack.&#39;</span><span class="p">)</span>
<span class="c1">## if (not isinstance(a, bool)</span>
<span class="c1">## or not isinstance(b, bool)</span>
<span class="c1">## ):</span> <span class="c1">## ):</span>
<span class="c1">## raise NotAnIntError</span> <span class="c1">## raise NotABoolError</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="p">)</span>
<span class="k">return</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span> <span class="k">return</span> <span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">stack</span><span class="p">),</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
<span class="k">return</span> <span class="n">inner</span></div> <span class="k">return</span> <span class="n">inner</span></div>
@@ -1364,27 +1384,27 @@
<span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</span> <span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">eq</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">eq</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">gt</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">gt</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lt</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lt</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ne</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ne</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">xor</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">xor</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lshift</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lshift</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">rshift</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">rshift</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">and_</span><span class="p">),</span> <span class="n">BinaryLogicWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">and_</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">or_</span><span class="p">),</span> <span class="n">BinaryLogicWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">or_</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">floordiv</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">floordiv</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mod</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mod</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">pow</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">pow</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">),</span> <span class="n">BinaryMathWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">),</span>
<span class="c1">## BinaryBuiltinWrapper(operator.truediv),</span> <span class="c1">## BinaryMathWrapper(operator.truediv),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">),</span> <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">),</span> <span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">),</span>
docs/sphinx_docs/_build/html/_modules/joy/parser.html
+5 -5
View File
@@ -60,18 +60,18 @@
<span class="sd">A crude grammar::</span> <span class="sd">A crude grammar::</span>
<span class="sd"> joy = term*</span> <span class="sd"> joy = term*</span>
<span class="sd"> term = int | float | string | &#39;[&#39; joy &#39;]&#39; | symbol</span> <span class="sd"> term = integer | &#39;[&#39; joy &#39;]&#39; | symbol</span>
<span class="sd">A Joy expression is a sequence of zero or more terms. A term is a</span> <span class="sd">A Joy expression is a sequence of zero or more terms. A term is a</span>
<span class="sd">literal value (integer, float, string, or Joy expression) or a function</span> <span class="sd">literal value (integer or Joy expression) or a function symbol.</span>
<span class="sd">symbol. Function symbols are unquoted strings and cannot contain square</span> <span class="sd">Function symbols are sequences of non-blanks and cannot contain square</span>
<span class="sd">brackets. Terms must be separated by blanks, which can be omitted</span> <span class="sd">brackets. Terms must be separated by blanks, which can be omitted</span>
<span class="sd">around square brackets.</span> <span class="sd">around square brackets.</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">re</span> <span class="kn">import</span> <span class="n">Scanner</span> <span class="kn">from</span> <span class="nn">re</span> <span class="kn">import</span> <span class="n">Scanner</span>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="kn">import</span> <span class="n">list_to_stack</span> <span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="kn">import</span> <span class="n">list_to_stack</span>
<span class="kn">from</span> <span class="nn">.utils.snippets</span> <span class="kn">import</span> <span class="p">(</span> <span class="kn">from</span> <span class="nn">joy.utils.snippets</span> <span class="kn">import</span> <span class="p">(</span>
<span class="n">pat</span> <span class="k">as</span> <span class="n">SNIPPETS</span><span class="p">,</span> <span class="n">pat</span> <span class="k">as</span> <span class="n">SNIPPETS</span><span class="p">,</span>
<span class="n">from_string</span><span class="p">,</span> <span class="n">from_string</span><span class="p">,</span>
<span class="n">Snippet</span><span class="p">,</span> <span class="n">Snippet</span><span class="p">,</span>
docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html
+19 -5
View File
@@ -56,6 +56,18 @@
<span class="sd">permits certain operations such as iterating and pushing and popping</span> <span class="sd">permits certain operations such as iterating and pushing and popping</span>
<span class="sd">values from (at least) one end.</span> <span class="sd">values from (at least) one end.</span>
<span class="sd"> In describing Joy I have used the term quotation to describe all of the</span>
<span class="sd"> above, because I needed a word to describe the arguments to combinators</span>
<span class="sd"> which fulfill the same role in Joy as lambda abstractions (with</span>
<span class="sd"> variables) fulfill in the more familiar functional languages. I use the</span>
<span class="sd"> term list for those quotations whose members are what I call literals:</span>
<span class="sd"> numbers, characters, truth values, sets, strings and other quotations.</span>
<span class="sd"> All these I call literals because their occurrence in code results in</span>
<span class="sd"> them being pushed onto the stack. But I also call [London Paris] a list.</span>
<span class="sd"> So, [dup \*] is a quotation but not a list.</span>
<span class="sd">`&quot;A Conversation with Manfred von Thun&quot; w/ Stevan Apter &lt;http://archive.vector.org.uk/art10000350&gt;`_ </span>
<span class="sd">There is no &quot;Stack&quot; Python class, instead we use the `cons list`_, a </span> <span class="sd">There is no &quot;Stack&quot; Python class, instead we use the `cons list`_, a </span>
<span class="sd">venerable two-tuple recursive sequence datastructure, where the</span> <span class="sd">venerable two-tuple recursive sequence datastructure, where the</span>
<span class="sd">empty tuple ``()`` is the empty stack and ``(head, rest)`` gives the</span> <span class="sd">empty tuple ``()`` is the empty stack and ``(head, rest)`` gives the</span>
@@ -95,7 +107,7 @@
<span class="sd">We have two very simple functions, one to build up a stack from a Python</span> <span class="sd">We have two very simple functions, one to build up a stack from a Python</span>
<span class="sd">iterable and another to iterate through a stack and yield its items</span> <span class="sd">list and another to iterate through a stack and yield its items</span>
<span class="sd">one-by-one in order. There are also two functions to generate string representations</span> <span class="sd">one-by-one in order. There are also two functions to generate string representations</span>
<span class="sd">of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions *internal stacks* are</span> <span class="sd">of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions *internal stacks* are</span>
<span class="sd">printed left-to-right. These functions are written to support :doc:`../pretty`.</span> <span class="sd">printed left-to-right. These functions are written to support :doc:`../pretty`.</span>
@@ -114,7 +126,9 @@
<span class="sd"> :param list el: A Python list or other sequence (iterators and generators</span> <span class="sd"> :param list el: A Python list or other sequence (iterators and generators</span>
<span class="sd"> won&#39;t work because ``reverse()`` is called on ``el``.)</span> <span class="sd"> won&#39;t work because ``reverse()`` is called on ``el``.)</span>
<span class="sd"> :param stack stack: A stack, optional, defaults to the empty stack.</span> <span class="sd"> :param stack stack: A stack, optional, defaults to the empty stack. This</span>
<span class="sd"> allows for concatinating Python lists (or other sequence objects)</span>
<span class="sd"> onto an existing Joy stack.</span>
<span class="sd"> :rtype: stack</span> <span class="sd"> :rtype: stack</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
@@ -196,12 +210,12 @@
<span class="sd"> :param stack quote: A stack.</span> <span class="sd"> :param stack quote: A stack.</span>
<span class="sd"> :param stack expression: A stack.</span> <span class="sd"> :param stack expression: A stack.</span>
<span class="sd"> :raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
<span class="sd"> :rtype: stack</span> <span class="sd"> :rtype: stack</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># This is the fastest implementation, but will trigger</span> <span class="c1"># This is the fastest implementation, but will trigger</span>
<span class="c1"># RuntimeError: maximum recursion depth exceeded</span> <span class="c1"># RuntimeError: maximum recursion depth exceeded</span>
<span class="c1"># on quotes longer than sys.getrecursionlimit().</span> <span class="c1"># on quotes longer than sys.getrecursionlimit().</span>
<span class="c1"># :raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
<span class="c1">## return (quote[0], concat(quote[1], expression)) if quote else expression</span> <span class="c1">## return (quote[0], concat(quote[1], expression)) if quote else expression</span>
@@ -212,10 +226,10 @@
<span class="c1"># In-lining is slightly faster (and won&#39;t break the</span> <span class="c1"># In-lining is slightly faster (and won&#39;t break the</span>
<span class="c1"># recursion limit on long quotes.)</span> <span class="c1"># recursion limit on long quotes.)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">raise</span> <span class="n">NotAListError</span><span class="p">(</span><span class="s1">&#39;Not a list.&#39;</span><span class="p">)</span>
<span class="n">temp</span> <span class="o">=</span> <span class="p">[]</span> <span class="n">temp</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">while</span> <span class="n">quote</span><span class="p">:</span> <span class="k">while</span> <span class="n">quote</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">raise</span> <span class="n">NotAListError</span><span class="p">(</span><span class="nb">repr</span><span class="p">(</span><span class="n">quote</span><span class="p">))</span>
<span class="n">item</span><span class="p">,</span> <span class="n">quote</span> <span class="o">=</span> <span class="n">quote</span> <span class="n">item</span><span class="p">,</span> <span class="n">quote</span> <span class="o">=</span> <span class="n">quote</span>
<span class="n">temp</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">item</span><span class="p">)</span> <span class="n">temp</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
<span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="n">temp</span><span class="p">):</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="n">temp</span><span class="p">):</span>
docs/sphinx_docs/_build/html/_sources/lib.rst.txt
+1 -1
View File
@@ -473,7 +473,7 @@ List words
"Swap stack" swap the list on the top of the stack for the stack, and "Swap stack" swap the list on the top of the stack for the stack, and
put the old stack on top of the new one. Think of it as a context put the old stack on top of the new one. Think of it as a context
switch. Niether of the lists/stacks change their order. switch. Neither of the lists/stacks change their order.
.. code:: python .. code:: python
docs/sphinx_docs/_build/html/_sources/notebooks/The_Four_Operations.rst.txt
+1 -1
View File
@@ -316,7 +316,7 @@ The other sub-programs would be cancelled.
“Fulminators” “Fulminators”
^^^^^^^^^^^^^ ^^^^^^^^^^^^^
Also known as “Futures” or “Promises” (by *everybody* else. “Fulinators” Also known as “Futures” or “Promises” (by *everybody* else. “Fulminators”
is what I was going to call them when I was thinking about implementing is what I was going to call them when I was thinking about implementing
them in Thun.) them in Thun.)
docs/sphinx_docs/_build/html/genindex.html
+3 -1
View File
@@ -78,10 +78,12 @@
<table style="width: 100%" class="indextable genindextable"><tr> <table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.b">b() (in module joy.library)</a> <li><a href="library.html#joy.library.b">b() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.BinaryLogicWrapper">BinaryLogicWrapper() (in module joy.library)</a>
</li> </li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.BinaryBuiltinWrapper">BinaryBuiltinWrapper() (in module joy.library)</a> <li><a href="library.html#joy.library.BinaryMathWrapper">BinaryMathWrapper() (in module joy.library)</a>
</li> </li>
<li><a href="library.html#joy.library.branch">branch() (in module joy.library)</a> <li><a href="library.html#joy.library.branch">branch() (in module joy.library)</a>
</li> </li>
docs/sphinx_docs/_build/html/joy.html
+10 -16
View File
@@ -59,27 +59,21 @@ match the behaviour of the original version(s) written in C.</p>
literals (strings, numbers, sequences of terms) or function symbols. literals (strings, numbers, sequences of terms) or function symbols.
Literals are put onto the stack and functions are looked up in the Literals are put onto the stack and functions are looked up in the
dictionary and executed.</p> dictionary and executed.</p>
<blockquote> <p>The viewer is a function that is called with the stack and expression
<div><p>The viewer is a function that is called with the stack and expression
on every iteration, its return value is ignored.</p> on every iteration, its return value is ignored.</p>
<dl class="field-list simple"> <dl class="field-list simple">
<dt class="field-odd">param stack stack</dt> <dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p>The stack.</p> <dd class="field-odd"><ul class="simple">
<li><p><strong>stack</strong> (<em>stack</em>) – The stack.</p></li>
<li><p><strong>expression</strong> (<em>stack</em>) – The expression to evaluate.</p></li>
<li><p><strong>dictionary</strong> (<em>dict</em>) – A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</p></li>
<li><p><strong>viewer</strong> (<em>function</em>) – Optional viewer function.</p></li>
</ul>
</dd> </dd>
<dt class="field-even">param stack expression</dt> <dt class="field-even">Return type</dt>
<dd class="field-even"><p>The expression to evaluate.</p> <dd class="field-even"><p>(stack, (), dictionary)</p>
</dd>
<dt class="field-odd">param dict dictionary</dt>
<dd class="field-odd"><p>A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</p>
</dd>
<dt class="field-even">param function viewer</dt>
<dd class="field-even"><p>Optional viewer function.</p>
</dd>
<dt class="field-odd">rtype</dt>
<dd class="field-odd"><p>(stack, (), dictionary)</p>
</dd> </dd>
</dl> </dl>
</div></blockquote>
</dd></dl> </dd></dl>
<dl class="py function"> <dl class="py function">
docs/sphinx_docs/_build/html/lib.html
+1 -1
View File
@@ -346,7 +346,7 @@ it’s “off the shelf” technology.)</p>
<h3><code class="docutils literal notranslate"><span class="pre">swaack</span></code><a class="headerlink" href="#swaack" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">swaack</span></code><a class="headerlink" href="#swaack" title="Permalink to this headline"></a></h3>
<p>“Swap stack” swap the list on the top of the stack for the stack, and <p>“Swap stack” swap the list on the top of the stack for the stack, and
put the old stack on top of the new one. Think of it as a context put the old stack on top of the new one. Think of it as a context
switch. Niether of the lists/stacks change their order.</p> switch. Neither of the lists/stacks change their order.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;1 2 3 [4 5 6] swaack&#39;</span><span class="p">)</span> <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;1 2 3 [4 5 6] swaack&#39;</span><span class="p">)</span>
</pre></div> </pre></div>
</div> </div>
docs/sphinx_docs/_build/html/library.html
+9 -3
View File
@@ -42,9 +42,15 @@ functions. Its main export is a Python function initialize() that
returns a dictionary of Joy functions suitable for use with the joy() returns a dictionary of Joy functions suitable for use with the joy()
function.</p> function.</p>
<dl class="py function"> <dl class="py function">
<dt class="sig sig-object py" id="joy.library.BinaryBuiltinWrapper"> <dt class="sig sig-object py" id="joy.library.BinaryLogicWrapper">
<span class="sig-prename descclassname"><span class="pre">joy.library.</span></span><span class="sig-name descname"><span class="pre">BinaryBuiltinWrapper</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">f</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#BinaryBuiltinWrapper"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.library.BinaryBuiltinWrapper" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.library.</span></span><span class="sig-name descname"><span class="pre">BinaryLogicWrapper</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">f</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#BinaryLogicWrapper"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.library.BinaryLogicWrapper" title="Permalink to this definition"></a></dt>
<dd><p>Wrap functions that take two arguments and return a single result.</p> <dd><p>Wrap functions that take two numbers and return a single result.</p>
</dd></dl>
<dl class="py function">
<dt class="sig sig-object py" id="joy.library.BinaryMathWrapper">
<span class="sig-prename descclassname"><span class="pre">joy.library.</span></span><span class="sig-name descname"><span class="pre">BinaryMathWrapper</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">f</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#BinaryMathWrapper"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.library.BinaryMathWrapper" title="Permalink to this definition"></a></dt>
<dd><p>Wrap functions that take two numbers and return a single result.</p>
</dd></dl> </dd></dl>
<dl class="py class"> <dl class="py class">
docs/sphinx_docs/_build/html/notebooks/The_Four_Operations.html
+1 -1
View File
@@ -298,7 +298,7 @@ stack could be replaced by its output stack.</p>
</section> </section>
<section id="fulminators"> <section id="fulminators">
<h4>“Fulminators”<a class="headerlink" href="#fulminators" title="Permalink to this headline"></a></h4> <h4>“Fulminators”<a class="headerlink" href="#fulminators" title="Permalink to this headline"></a></h4>
<p>Also known as “Futures” or “Promises” (by <em>everybody</em> else. “Fulinators” <p>Also known as “Futures” or “Promises” (by <em>everybody</em> else. “Fulminators”
is what I was going to call them when I was thinking about implementing is what I was going to call them when I was thinking about implementing
them in Thun.)</p> them in Thun.)</p>
<p>The runtime could be amended to permit “thunks” representing the results <p>The runtime could be amended to permit “thunks” representing the results
docs/sphinx_docs/_build/html/objects.inv
BIN
View File
Binary file not shown.
docs/sphinx_docs/_build/html/parser.html
+3 -3
View File
@@ -44,12 +44,12 @@ expression as well as a single Symbol class and a single Exception type.</p>
by the fact that they are not Symbol objects.</p> by the fact that they are not Symbol objects.</p>
<p>A crude grammar:</p> <p>A crude grammar:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span>
<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">symbol</span> <span class="n">term</span> <span class="o">=</span> <span class="n">integer</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">symbol</span>
</pre></div> </pre></div>
</div> </div>
<p>A Joy expression is a sequence of zero or more terms. A term is a <p>A Joy expression is a sequence of zero or more terms. A term is a
literal value (integer, float, string, or Joy expression) or a function literal value (integer or Joy expression) or a function symbol.
symbol. Function symbols are unquoted strings and cannot contain square Function symbols are sequences of non-blanks and cannot contain square
brackets. Terms must be separated by blanks, which can be omitted brackets. Terms must be separated by blanks, which can be omitted
around square brackets.</p> around square brackets.</p>
<dl class="py exception"> <dl class="py exception">
docs/sphinx_docs/_build/html/searchindex.js
+1 -1
View File
File diff suppressed because one or more lines are too long
docs/sphinx_docs/_build/html/stack.html
+18 -7
View File
@@ -41,6 +41,18 @@
“list”, and others to mean the same thing: a simple linear datatype that “list”, and others to mean the same thing: a simple linear datatype that
permits certain operations such as iterating and pushing and popping permits certain operations such as iterating and pushing and popping
values from (at least) one end.</p> values from (at least) one end.</p>
<blockquote>
<div><p>In describing Joy I have used the term quotation to describe all of the
above, because I needed a word to describe the arguments to combinators
which fulfill the same role in Joy as lambda abstractions (with
variables) fulfill in the more familiar functional languages. I use the
term list for those quotations whose members are what I call literals:
numbers, characters, truth values, sets, strings and other quotations.
All these I call literals because their occurrence in code results in
them being pushed onto the stack. But I also call [London Paris] a list.
So, [dup *] is a quotation but not a list.</p>
</div></blockquote>
<p><a class="reference external" href="http://archive.vector.org.uk/art10000350">“A Conversation with Manfred von Thun” w/ Stevan Apter</a></p>
<p>There is no “Stack” Python class, instead we use the <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons list</a>, a <p>There is no “Stack” Python class, instead we use the <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons list</a>, a
venerable two-tuple recursive sequence datastructure, where the venerable two-tuple recursive sequence datastructure, where the
empty tuple <code class="docutils literal notranslate"><span class="pre">()</span></code> is the empty stack and <code class="docutils literal notranslate"><span class="pre">(head,</span> <span class="pre">rest)</span></code> gives the empty tuple <code class="docutils literal notranslate"><span class="pre">()</span></code> is the empty stack and <code class="docutils literal notranslate"><span class="pre">(head,</span> <span class="pre">rest)</span></code> gives the
@@ -77,7 +89,7 @@ syntax was removed entirely. Instead you would have to write:</p>
</pre></div> </pre></div>
</div> </div>
<p>We have two very simple functions, one to build up a stack from a Python <p>We have two very simple functions, one to build up a stack from a Python
iterable and another to iterate through a stack and yield its items list and another to iterate through a stack and yield its items
one-by-one in order. There are also two functions to generate string representations one-by-one in order. There are also two functions to generate string representations
of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions <em>internal stacks</em> are of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions <em>internal stacks</em> are
printed left-to-right. These functions are written to support <a class="reference internal" href="pretty.html"><span class="doc">Tracing Joy Execution</span></a>.</p> printed left-to-right. These functions are written to support <a class="reference internal" href="pretty.html"><span class="doc">Tracing Joy Execution</span></a>.</p>
@@ -93,11 +105,8 @@ printed left-to-right. These functions are written to support <a class="referen
<li><p><strong>expression</strong> (<em>stack</em>) – A stack.</p></li> <li><p><strong>expression</strong> (<em>stack</em>) – A stack.</p></li>
</ul> </ul>
</dd> </dd>
<dt class="field-even">Raises</dt> <dt class="field-even">Return type</dt>
<dd class="field-even"><p><strong>RuntimeError</strong> – if quote is larger than sys.getrecursionlimit().</p> <dd class="field-even"><p>stack</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>stack</p>
</dd> </dd>
</dl> </dl>
</dd></dl> </dd></dl>
@@ -158,7 +167,9 @@ rearranging of the stack from e.g. the StackListbox.</p>
<dd class="field-odd"><ul class="simple"> <dd class="field-odd"><ul class="simple">
<li><p><strong>el</strong> (<em>list</em>) – A Python list or other sequence (iterators and generators <li><p><strong>el</strong> (<em>list</em>) – A Python list or other sequence (iterators and generators
won’t work because <code class="docutils literal notranslate"><span class="pre">reverse()</span></code> is called on <code class="docutils literal notranslate"><span class="pre">el</span></code>.)</p></li> won’t work because <code class="docutils literal notranslate"><span class="pre">reverse()</span></code> is called on <code class="docutils literal notranslate"><span class="pre">el</span></code>.)</p></li>
<li><p><strong>stack</strong> (<em>stack</em>) – A stack, optional, defaults to the empty stack.</p></li> <li><p><strong>stack</strong> (<em>stack</em>) – A stack, optional, defaults to the empty stack. This
allows for concatinating Python lists (or other sequence objects)
onto an existing Joy stack.</p></li>
</ul> </ul>
</dd> </dd>
<dt class="field-even">Return type</dt> <dt class="field-even">Return type</dt>
implementations/Python/joy/utils/stack.py
+10 -11
View File
@@ -23,18 +23,17 @@ When talking about Joy we use the terms "stack", "quote", "sequence",
permits certain operations such as iterating and pushing and popping permits certain operations such as iterating and pushing and popping
values from (at least) one end. values from (at least) one end.
> In describing Joy I have used the term quotation to describe all of the In describing Joy I have used the term quotation to describe all of the
above, because I needed a word to describe the arguments to combinators above, because I needed a word to describe the arguments to combinators
which fulfill the same role in Joy as lambda abstractions (with which fulfill the same role in Joy as lambda abstractions (with
variables) fulfill in the more familiar functional languages. I use the variables) fulfill in the more familiar functional languages. I use the
term list for those quotations whose members are what I call literals: term list for those quotations whose members are what I call literals:
numbers, characters, truth values, sets, strings and other quotations. numbers, characters, truth values, sets, strings and other quotations.
All these I call literals because their occurrence in code results in All these I call literals because their occurrence in code results in
them being pushed onto the stack. But I also call [London Paris] a list. them being pushed onto the stack. But I also call [London Paris] a list.
So, [dup *] is a quotation but not a list. So, [dup \*] is a quotation but not a list.
"A Conversation with Manfred von Thun" w/ Stevan Apter `"A Conversation with Manfred von Thun" w/ Stevan Apter <http://archive.vector.org.uk/art10000350>`_
http://archive.vector.org.uk/art10000350
There is no "Stack" Python class, instead we use the `cons list`_, a There is no "Stack" Python class, instead we use the `cons list`_, a
venerable two-tuple recursive sequence datastructure, where the venerable two-tuple recursive sequence datastructure, where the