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

Using Sphinx 4.3.0

This commit is contained in:
Simon Forman 2021-11-19 12:46:29 -08:00
parent 918aafb139
commit eeda5044ad
44 changed files with 6403 additions and 5626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
docs/sphinx_docs/_build/html/_modules/index.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Overview: module code &#8212; Thun 0.4.1 documentation</title> <title>Overview: module code &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
@ -28,24 +26,48 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1>All modules for which code is available</h1> <h1>All modules for which code is available</h1>
<ul><li><a href="__builtin__.html">__builtin__</a></li> <ul><li><a href="joy/joy.html">joy.joy</a></li>
<li><a href="joy/joy.html">joy.joy</a></li>
<li><a href="joy/library.html">joy.library</a></li> <li><a href="joy/library.html">joy.library</a></li>
<li><a href="joy/parser.html">joy.parser</a></li> <li><a href="joy/parser.html">joy.parser</a></li>
<li><a href="joy/utils/generated_library.html">joy.utils.generated_library</a></li> <li><a href="joy/utils/generated_library.html">joy.utils.generated_library</a></li>
<li><a href="joy/utils/pretty_print.html">joy.utils.pretty_print</a></li> <li><a href="joy/utils/pretty_print.html">joy.utils.pretty_print</a></li>
<li><a href="joy/utils/stack.html">joy.utils.stack</a></li> <li><a href="joy/utils/stack.html">joy.utils.stack</a></li>
<li><a href="joy/utils/types.html">joy.utils.types</a></li>
</ul> </ul>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
@ -53,17 +75,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -74,7 +102,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

236
docs/sphinx_docs/_build/html/_modules/joy/joy.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>joy.joy &#8212; Thun 0.4.1 documentation</title> <title>joy.joy &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../_static/pygments.css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../_static/alabaster.css" />
<script type="text/javascript" src="../../_static/documentation_options.js"></script> <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
<script type="text/javascript" src="../../_static/jquery.js"></script> <script src="../../_static/jquery.js"></script>
<script type="text/javascript" src="../../_static/underscore.js"></script> <script src="../../_static/underscore.js"></script>
<script type="text/javascript" src="../../_static/doctools.js"></script> <script src="../../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../../genindex.html" /> <link rel="index" title="Index" href="../../genindex.html" />
<link rel="search" title="Search" href="../../search.html" /> <link rel="search" title="Search" href="../../search.html" />
@ -28,6 +26,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1>Source code for joy.joy</h1><div class="highlight"><pre> <h1>Source code for joy.joy</h1><div class="highlight"><pre>
@ -56,98 +56,162 @@
<span class="sd">match the behaviour of the original version(s) written in C.</span> <span class="sd">match the behaviour of the original version(s) written in C.</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span> <span class="kn">from</span> <span class="nn">builtins</span> <span class="kn">import</span> <span class="nb">input</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="kn">import</span> <span class="n">print_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="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">.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="kn">import</span> <span class="n">stack_to_string</span>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">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="n">NotAListError</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="p">)</span>
<div class="viewcode-block" id="UnknownSymbolError"><a class="viewcode-back" href="../../joy.html#joy.joy.UnknownSymbolError">[docs]</a><span class="k">class</span> <span class="nc">UnknownSymbolError</span><span class="p">(</span><span class="ne">KeyError</span><span class="p">):</span> <span class="k">pass</span></div>
<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;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"> disctionary 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>
<span class="sd"> :param stack stack: The stack.</span> <span class="sd"> :param stack stack: The stack.</span>
<span class="sd"> :param stack expression: The expression to evaluate.</span> <span class="sd"> :param stack expression: The expression to evaluate.</span>
<span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span> <span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
<span class="sd"> :param function viewer: Optional viewer function.</span> <span class="sd"> :param function viewer: Optional viewer function.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</span> <span class="sd"> :rtype: (stack, (), dictionary)</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">while</span> <span class="n">expression</span><span class="p">:</span> <span class="k">while</span> <span class="n">expression</span><span class="p">:</span>
<span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</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">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</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">term</span><span class="p">,</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">expression</span> <span class="n">term</span><span class="p">,</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">expression</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">term</span><span class="p">,</span> <span class="n">Symbol</span><span class="p">):</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">term</span><span class="p">,</span> <span class="n">Symbol</span><span class="p">):</span>
<span class="n">term</span> <span class="o">=</span> <span class="n">dictionary</span><span class="p">[</span><span class="n">term</span><span class="p">]</span> <span class="k">try</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="o">=</span> <span class="n">term</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">term</span> <span class="o">=</span> <span class="n">dictionary</span><span class="p">[</span><span class="n">term</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span> <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">stack</span> <span class="k">raise</span> <span class="n">UnknownSymbolError</span><span class="p">(</span><span class="n">term</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="o">=</span> <span class="n">term</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">else</span><span class="p">:</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">stack</span>
<span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</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">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</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="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div> <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
<div class="viewcode-block" id="run"><a class="viewcode-back" href="../../joy.html#joy.joy.run">[docs]</a><span class="k">def</span> <span class="nf">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="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <div class="viewcode-block" id="run"><a class="viewcode-back" href="../../joy.html#joy.joy.run">[docs]</a><span class="k">def</span> <span class="nf">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="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return the stack resulting from running the Joy code text on the stack.</span> <span class="sd"> Return the stack resulting from running the Joy code text on the stack.</span>
<span class="sd"> :param str text: Joy code.</span> <span class="sd"> :param str text: Joy code.</span>
<span class="sd"> :param stack stack: The stack.</span> <span class="sd"> :param stack stack: The stack.</span>
<span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span> <span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
<span class="sd"> :param function viewer: Optional viewer function.</span> <span class="sd"> :param function viewer: Optional viewer function.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</span> <span class="sd"> :rtype: (stack, (), dictionary)</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
<span class="k">return</span> <span class="n">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="p">)</span></div> <span class="k">return</span> <span class="n">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="p">)</span></div>
<div class="viewcode-block" id="repl"><a class="viewcode-back" href="../../joy.html#joy.joy.repl">[docs]</a><span class="k">def</span> <span class="nf">repl</span><span class="p">(</span><span class="n">stack</span><span class="o">=</span><span class="p">(),</span> <span class="n">dictionary</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <div class="viewcode-block" id="repl"><a class="viewcode-back" href="../../joy.html#joy.joy.repl">[docs]</a><span class="k">def</span> <span class="nf">repl</span><span class="p">(</span><span class="n">stack</span><span class="o">=</span><span class="p">(),</span> <span class="n">dictionary</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Read-Evaluate-Print Loop</span> <span class="sd"> Read-Evaluate-Print Loop</span>
<span class="sd"> Accept input and run it on the stack, loop.</span> <span class="sd"> Accept input and run it on the stack, loop.</span>
<span class="sd"> :param stack stack: The stack.</span> <span class="sd"> :param stack stack: The stack.</span>
<span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span> <span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</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="k">if</span> <span class="n">dictionary</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span> <span class="k">if</span> <span class="n">dictionary</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">dictionary</span> <span class="o">=</span> <span class="p">{}</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span> <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="nb">print</span><span class="p">()</span> <span class="nb">print</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="s1">&#39;&lt;-top&#39;</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="s1">&#39;&lt;-top&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">()</span> <span class="nb">print</span><span class="p">()</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="n">text</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">&#39;joy? &#39;</span><span class="p">)</span> <span class="n">text</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">&#39;joy? &#39;</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">EOFError</span><span class="p">,</span> <span class="ne">KeyboardInterrupt</span><span class="p">):</span> <span class="k">except</span> <span class="p">(</span><span class="ne">EOFError</span><span class="p">,</span> <span class="ne">KeyboardInterrupt</span><span class="p">):</span>
<span class="k">break</span> <span class="k">break</span>
<span class="k">try</span><span class="p">:</span> <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="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="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="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="nb">print</span><span class="p">()</span>
<span class="k">return</span> <span class="n">stack</span></div> <span class="k">return</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="interp"><a class="viewcode-back" href="../../joy.html#joy.joy.interp">[docs]</a><span class="k">def</span> <span class="nf">interp</span><span class="p">(</span><span class="n">stack</span><span class="o">=</span><span class="p">(),</span> <span class="n">dictionary</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Simple REPL with no extra output, suitable for use in scripts.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">if</span> <span class="n">dictionary</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">dictionary</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">text</span> <span class="o">=</span> <span class="nb">input</span><span class="p">()</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">EOFError</span><span class="p">,</span> <span class="ne">KeyboardInterrupt</span><span class="p">):</span>
<span class="k">break</span>
<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="n">UnknownSymbolError</span> <span class="k">as</span> <span class="n">sym</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Unknown:&#39;</span><span class="p">,</span> <span class="n">sym</span><span class="p">)</span>
<span class="k">except</span> <span class="n">StackUnderflowError</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 enough values on stack.&#39;</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="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="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><span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</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="k">return</span> <span class="n">stack</span></div>
</pre></div> </pre></div>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../../index.html">Documentation overview</a><ul> <li><a href="../../index.html">Documentation overview</a><ul>
@ -157,17 +221,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../../search.html" method="get"> <form class="search" action="../../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -178,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

1694
docs/sphinx_docs/_build/html/_modules/joy/library.html
View File

File diff suppressed because it is too large Load Diff

192
docs/sphinx_docs/_build/html/_modules/joy/parser.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>joy.parser &#8212; Thun 0.4.1 documentation</title> <title>joy.parser &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../_static/pygments.css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../_static/alabaster.css" />
<script type="text/javascript" src="../../_static/documentation_options.js"></script> <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
<script type="text/javascript" src="../../_static/jquery.js"></script> <script src="../../_static/jquery.js"></script>
<script type="text/javascript" src="../../_static/underscore.js"></script> <script src="../../_static/underscore.js"></script>
<script type="text/javascript" src="../../_static/doctools.js"></script> <script src="../../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../../genindex.html" /> <link rel="index" title="Index" href="../../genindex.html" />
<link rel="search" title="Search" href="../../search.html" /> <link rel="search" title="Search" href="../../search.html" />
@ -28,6 +26,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1>Source code for joy.parser</h1><div class="highlight"><pre> <h1>Source code for joy.parser</h1><div class="highlight"><pre>
@ -69,99 +69,121 @@
<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="k">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="k">import</span> <span class="n">list_to_stack</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="c1">#TODO: explain the details of float lits and strings.</span>
<span class="n">FLOAT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*(e(-|\+)\d+)?&#39;</span>
<span class="n">INT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+&#39;</span>
<span class="n">SYMBOL</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;[•\w!@$%^&amp;*()_+&lt;&gt;?|\/;:`~,.=-]+&#39;</span>
<span class="n">BRACKETS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</span> <span class="n">BRACKETS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</span>
<span class="n">STRING_DOUBLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;&quot;(?:[^&quot;</span><span class="se">\\</span><span class="s1">]|</span><span class="se">\\</span><span class="s1">.)*&quot;&#39;</span>
<span class="n">STRING_SINGLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s2">&quot;&#39;(?:[^&#39;</span><span class="se">\\</span><span class="s2">]|</span><span class="se">\\</span><span class="s2">.)*&#39;&quot;</span>
<span class="n">BLANKS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\s+&#39;</span> <span class="n">BLANKS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\s+&#39;</span>
<span class="n">WORDS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;[^[\]\s]+&#39;</span>
<span class="n">token_scanner</span> <span class="o">=</span> <span class="n">Scanner</span><span class="p">([</span>
<span class="p">(</span><span class="n">BRACKETS</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span>
<span class="p">(</span><span class="n">BLANKS</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="p">(</span><span class="n">WORDS</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span>
<span class="p">])</span>
<div class="viewcode-block" id="Symbol"><a class="viewcode-back" href="../../parser.html#joy.parser.Symbol">[docs]</a><span class="k">class</span> <span class="nc">Symbol</span><span class="p">(</span><span class="nb">str</span><span class="p">):</span> <div class="viewcode-block" id="Symbol"><a class="viewcode-back" href="../../parser.html#joy.parser.Symbol">[docs]</a><span class="k">class</span> <span class="nc">Symbol</span><span class="p">(</span><span class="nb">str</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span>
<span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div> <span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div>
<div class="viewcode-block" id="text_to_expression"><a class="viewcode-back" href="../../parser.html#joy.parser.text_to_expression">[docs]</a><span class="k">def</span> <span class="nf">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">):</span> <div class="viewcode-block" id="text_to_expression"><a class="viewcode-back" href="../../parser.html#joy.parser.text_to_expression">[docs]</a><span class="k">def</span> <span class="nf">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Convert a string to a Joy expression.</span> <span class="sd">&#39;&#39;&#39;Convert a string to a Joy expression.</span>
<span class="sd"> When supplied with a string this function returns a Python datastructure</span> <span class="sd"> When supplied with a string this function returns a Python datastructure</span>
<span class="sd"> that represents the Joy datastructure described by the text expression.</span> <span class="sd"> that represents the Joy datastructure described by the text expression.</span>
<span class="sd"> Any unbalanced square brackets will raise a ParseError.</span> <span class="sd"> Any unbalanced square brackets will raise a ParseError.</span>
<span class="sd"> :param str text: Text to convert.</span> <span class="sd"> :param str text: Text to convert.</span>
<span class="sd"> :rtype: stack</span> <span class="sd"> :rtype: stack</span>
<span class="sd"> :raises ParseError: if the parse fails.</span> <span class="sd"> :raises ParseError: if the parse fails.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">return</span> <span class="n">_parse</span><span class="p">(</span><span class="n">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">))</span></div> <span class="k">return</span> <span class="n">_parse</span><span class="p">(</span><span class="n">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">))</span></div>
<div class="viewcode-block" id="ParseError"><a class="viewcode-back" href="../../parser.html#joy.parser.ParseError">[docs]</a><span class="k">class</span> <span class="nc">ParseError</span><span class="p">(</span><span class="ne">ValueError</span><span class="p">):</span> <div class="viewcode-block" id="ParseError"><a class="viewcode-back" href="../../parser.html#joy.parser.ParseError">[docs]</a><span class="k">class</span> <span class="nc">ParseError</span><span class="p">(</span><span class="ne">ValueError</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Raised when there is a error while parsing text.&#39;&#39;&#39;</span></div> <span class="sd">&#39;&#39;&#39;Raised when there is a error while parsing text.&#39;&#39;&#39;</span></div>
<span class="k">def</span> <span class="nf">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">):</span> <span class="k">def</span> <span class="nf">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Convert a text into a stream of tokens.</span> <span class="sd">&#39;&#39;&#39;Convert a text into a stream of tokens.</span>
<span class="sd"> Converts function names to Symbols.</span> <span class="sd"> Converts function names to Symbols.</span>
<span class="sd"> Raise ParseError (with some of the failing text) if the scan fails.</span> <span class="sd"> Raise ParseError (with some of the failing text) if the scan fails.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">tokens</span><span class="p">,</span> <span class="n">rest</span> <span class="o">=</span> <span class="n">_scanner</span><span class="o">.</span><span class="n">scan</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="n">tokens</span><span class="p">,</span> <span class="n">rest</span> <span class="o">=</span> <span class="n">token_scanner</span><span class="o">.</span><span class="n">scan</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
<span class="k">if</span> <span class="n">rest</span><span class="p">:</span> <span class="k">if</span> <span class="n">rest</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span> <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span>
<span class="s1">&#39;Scan failed at position </span><span class="si">%i</span><span class="s1">, </span><span class="si">%r</span><span class="s1">&#39;</span> <span class="s1">&#39;Scan failed at position </span><span class="si">%i</span><span class="s1">, </span><span class="si">%r</span><span class="s1">&#39;</span>
<span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="o">-</span> <span class="nb">len</span><span class="p">(</span><span class="n">rest</span><span class="p">),</span> <span class="n">rest</span><span class="p">[:</span><span class="mi">10</span><span class="p">])</span> <span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="o">-</span> <span class="nb">len</span><span class="p">(</span><span class="n">rest</span><span class="p">),</span> <span class="n">rest</span><span class="p">[:</span><span class="mi">10</span><span class="p">])</span>
<span class="p">)</span> <span class="p">)</span>
<span class="k">return</span> <span class="n">tokens</span> <span class="k">return</span> <span class="n">tokens</span>
<span class="k">def</span> <span class="nf">_parse</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="k">def</span> <span class="nf">_parse</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a stack/list expression of the tokens.</span> <span class="sd"> Return a stack/list expression of the tokens.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span> <span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">stack</span> <span class="o">=</span> <span class="p">[]</span> <span class="n">stack</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">tok</span> <span class="ow">in</span> <span class="n">tokens</span><span class="p">:</span> <span class="k">for</span> <span class="n">tok</span> <span class="ow">in</span> <span class="n">tokens</span><span class="p">:</span>
<span class="k">if</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;[&#39;</span><span class="p">:</span> <span class="k">if</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;[&#39;</span><span class="p">:</span>
<span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span> <span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
<span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span> <span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">stack</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span> <span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;]&#39;</span><span class="p">:</span>
<span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;]&#39;</span><span class="p">:</span> <span class="n">v</span> <span class="o">=</span> <span class="n">frame</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span> <span class="n">frame</span> <span class="o">=</span> <span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="n">frame</span> <span class="o">=</span> <span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span> <span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span> <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Extra closing bracket.&#39;</span><span class="p">)</span>
<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Extra closing bracket.&#39;</span><span class="p">)</span> <span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">list_to_stack</span><span class="p">(</span><span class="n">v</span><span class="p">))</span>
<span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span> <span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;true&#39;</span><span class="p">:</span>
<span class="k">else</span><span class="p">:</span> <span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>
<span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">tok</span><span class="p">)</span> <span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;false&#39;</span><span class="p">:</span>
<span class="k">if</span> <span class="n">stack</span><span class="p">:</span> <span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Unclosed bracket.&#39;</span><span class="p">)</span> <span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span> <span class="k">try</span><span class="p">:</span>
<span class="n">thing</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">tok</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="n">_scanner</span> <span class="o">=</span> <span class="n">Scanner</span><span class="p">([</span> <span class="n">thing</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="n">tok</span><span class="p">)</span>
<span class="p">(</span><span class="n">FLOAT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span> <span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">thing</span><span class="p">)</span>
<span class="p">(</span><span class="n">INT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span> <span class="k">if</span> <span class="n">stack</span><span class="p">:</span>
<span class="p">(</span><span class="n">SYMBOL</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">Symbol</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span> <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Unclosed bracket.&#39;</span><span class="p">)</span>
<span class="p">(</span><span class="n">BRACKETS</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span> <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
<span class="p">(</span><span class="n">STRING_DOUBLE_QUOTED</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\\</span><span class="s1">&quot;&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">)),</span>
<span class="p">(</span><span class="n">STRING_SINGLE_QUOTED</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\\</span><span class="s2">&#39;&quot;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">)),</span>
<span class="p">(</span><span class="n">BLANKS</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="p">])</span>
</pre></div> </pre></div>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../../index.html">Documentation overview</a><ul> <li><a href="../../index.html">Documentation overview</a><ul>
@ -171,17 +193,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../../search.html" method="get"> <form class="search" action="../../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -192,7 +220,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

205
docs/sphinx_docs/_build/html/_modules/joy/utils/pretty_print.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>joy.utils.pretty_print &#8212; Thun 0.4.1 documentation</title> <title>joy.utils.pretty_print &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../../../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css" />
<link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../../_static/alabaster.css" />
<script type="text/javascript" src="../../../_static/documentation_options.js"></script> <script data-url_root="../../../" id="documentation_options" src="../../../_static/documentation_options.js"></script>
<script type="text/javascript" src="../../../_static/jquery.js"></script> <script src="../../../_static/jquery.js"></script>
<script type="text/javascript" src="../../../_static/underscore.js"></script> <script src="../../../_static/underscore.js"></script>
<script type="text/javascript" src="../../../_static/doctools.js"></script> <script src="../../../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../../../genindex.html" /> <link rel="index" title="Index" href="../../../genindex.html" />
<link rel="search" title="Search" href="../../../search.html" /> <link rel="search" title="Search" href="../../../search.html" />
@ -28,6 +26,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1>Source code for joy.utils.pretty_print</h1><div class="highlight"><pre> <h1>Source code for joy.utils.pretty_print</h1><div class="highlight"><pre>
@ -71,100 +71,121 @@
<span class="sd">&#39;&#39;&#39;</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"># (Kinda clunky and hacky. This should be swapped out in favor of much</span>
<span class="c1"># smarter stuff.)</span> <span class="c1"># smarter stuff.)</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">traceback</span> <span class="kn">import</span> <span class="n">print_exc</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">object</span> <span class="kn">from</span> <span class="nn">.stack</span> <span class="kn">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">stack_to_string</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">..joy</span> <span class="kn">import</span> <span class="n">joy</span>
<span class="kn">from</span> <span class="nn">.stack</span> <span class="k">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">stack_to_string</span> <span class="kn">from</span> <span class="nn">..library</span> <span class="kn">import</span> <span class="n">FunctionWrapper</span>
<span class="kn">from</span> <span class="nn">..joy</span> <span class="k">import</span> <span class="n">joy</span>
<span class="kn">from</span> <span class="nn">..library</span> <span class="k">import</span> <span class="n">inscribe</span><span class="p">,</span> <span class="n">FunctionWrapper</span>
<div class="viewcode-block" id="trace"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.trace">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="trace"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.trace">[docs]</a><span class="nd">@FunctionWrapper</span>
<span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">trace</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">def</span> <span class="nf">trace</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a stack and print a trace.</span> <span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a stack and print a trace.</span>
<span class="sd"> This function is just like the `i` combinator but it also prints a</span> <span class="sd"> This function is just like the `i` combinator but it also prints a</span>
<span class="sd"> trace of the evaluation</span> <span class="sd"> trace of the evaluation</span>
<span class="sd"> :param stack stack: The stack.</span> <span class="sd"> :param stack stack: The stack.</span>
<span class="sd"> :param stack expression: The expression to evaluate.</span> <span class="sd"> :param stack expression: The expression to evaluate.</span>
<span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span> <span class="sd"> :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</span> <span class="sd"> :rtype: (stack, (), dictionary)</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">tp</span> <span class="o">=</span> <span class="n">TracePrinter</span><span class="p">()</span> <span class="n">tp</span> <span class="o">=</span> <span class="n">TracePrinter</span><span class="p">()</span>
<span class="n">quote</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span> <span class="n">quote</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="n">s</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">d</span> <span class="o">=</span> <span class="n">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">quote</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">tp</span><span class="o">.</span><span class="n">viewer</span><span class="p">)</span> <span class="n">s</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">d</span> <span class="o">=</span> <span class="n">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">quote</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">tp</span><span class="o">.</span><span class="n">viewer</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">tp</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="n">tp</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;-&#39;</span> <span class="o">*</span> <span class="mi">73</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;-&#39;</span> <span class="o">*</span> <span class="mi">73</span><span class="p">)</span>
<span class="k">raise</span> <span class="k">raise</span>
<span class="k">else</span><span class="p">:</span> <span class="k">else</span><span class="p">:</span>
<span class="n">tp</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="n">tp</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
<span class="k">return</span> <span class="n">s</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">d</span></div> <span class="k">return</span> <span class="n">s</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">d</span></div>
<div class="viewcode-block" id="TracePrinter"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter">[docs]</a><span class="k">class</span> <span class="nc">TracePrinter</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <div class="viewcode-block" id="TracePrinter"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter">[docs]</a><span class="k">class</span> <span class="nc">TracePrinter</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> This is what does the formatting. You instantiate it and pass the ``viewer()``</span> <span class="sd"> This is what does the formatting. You instantiate it and pass the ``viewer()``</span>
<span class="sd"> method to the :py:func:`joy.joy.joy` function, then print it to see the</span> <span class="sd"> method to the :py:func:`joy.joy.joy` function, then print it to see the</span>
<span class="sd"> trace.</span> <span class="sd"> trace.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="p">[]</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="p">[]</span>
<div class="viewcode-block" id="TracePrinter.viewer"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.viewer">[docs]</a> <span class="k">def</span> <span class="nf">viewer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span> <div class="viewcode-block" id="TracePrinter.viewer"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.viewer">[docs]</a> <span class="k">def</span> <span class="nf">viewer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Record the current stack and expression in the TracePrinter&#39;s history.</span> <span class="sd"> Record the current stack and expression in the TracePrinter&#39;s history.</span>
<span class="sd"> Pass this method as the ``viewer`` argument to the :py:func:`joy.joy.joy` function.</span> <span class="sd"> Pass this method as the ``viewer`` argument to the :py:func:`joy.joy.joy` function.</span>
<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"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span></div> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span></div>
<span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">def</span> <span class="fm">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">go</span><span class="p">())</span> <span class="k">return</span> <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">go</span><span class="p">())</span>
<div class="viewcode-block" id="TracePrinter.go"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.go">[docs]</a> <span class="k">def</span> <span class="nf">go</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <div class="viewcode-block" id="TracePrinter.go"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.go">[docs]</a> <span class="k">def</span> <span class="nf">go</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a list of strings, one for each entry in the history, prefixed</span> <span class="sd"> Return a list of strings, one for each entry in the history, prefixed</span>
<span class="sd"> with enough spaces to align all the interpreter dots.</span> <span class="sd"> with enough spaces to align all the interpreter dots.</span>
<span class="sd"> This method is called internally by the ``__str__()`` method.</span> <span class="sd"> This method is called internally by the ``__str__()`` method.</span>
<span class="sd"> :rtype: list(str)</span> <span class="sd"> :rtype: list(str)</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">max_stack_length</span> <span class="o">=</span> <span class="mi">0</span> <span class="n">max_stack_length</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">lines</span> <span class="o">=</span> <span class="p">[]</span> <span class="n">lines</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">:</span> <span class="k">for</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">:</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">)</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">)</span>
<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="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="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">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="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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">lines</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="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="o">=</span> <span class="n">lines</span><span class="p">[</span><span class="n">i</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="n">lines</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</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="p">]</span></div> <span class="k">return</span> <span class="n">lines</span></div>
<span class="k">def</span> <span class="nf">print_</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">def</span> <span class="nf">print_</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="bp">self</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="s1">&#39;Exception while printing viewer.&#39;</span><span class="p">)</span></div> <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Exception while printing viewer.&#39;</span><span class="p">)</span></div>
</pre></div> </pre></div>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../../../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../../notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../../../index.html">Documentation overview</a><ul> <li><a href="../../../index.html">Documentation overview</a><ul>
@ -174,17 +195,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../../../search.html" method="get"> <form class="search" action="../../../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -195,7 +222,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

296
docs/sphinx_docs/_build/html/_modules/joy/utils/stack.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>joy.utils.stack &#8212; Thun 0.4.1 documentation</title> <title>joy.utils.stack &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../../../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css" />
<link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../../../_static/alabaster.css" />
<script type="text/javascript" src="../../../_static/documentation_options.js"></script> <script data-url_root="../../../" id="documentation_options" src="../../../_static/documentation_options.js"></script>
<script type="text/javascript" src="../../../_static/jquery.js"></script> <script src="../../../_static/jquery.js"></script>
<script type="text/javascript" src="../../../_static/underscore.js"></script> <script src="../../../_static/underscore.js"></script>
<script type="text/javascript" src="../../../_static/doctools.js"></script> <script src="../../../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../../../genindex.html" /> <link rel="index" title="Index" href="../../../genindex.html" />
<link rel="search" title="Search" href="../../../search.html" /> <link rel="search" title="Search" href="../../../search.html" />
@ -28,6 +26,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1>Source code for joy.utils.stack</h1><div class="highlight"><pre> <h1>Source code for joy.utils.stack</h1><div class="highlight"><pre>
@ -76,8 +76,8 @@
<span class="sd">For example::</span> <span class="sd">For example::</span>
<span class="sd"> def dup((head, tail)):</span> <span class="sd"> def dup((head, tail)):</span>
<span class="sd"> return head, (head, tail)</span> <span class="sd"> return head, (head, tail)</span>
<span class="sd">We replace the argument &quot;stack&quot; by the expected structure of the stack,</span> <span class="sd">We replace the argument &quot;stack&quot; by the expected structure of the stack,</span>
<span class="sd">in this case &quot;(head, tail)&quot;, and Python takes care of unpacking the</span> <span class="sd">in this case &quot;(head, tail)&quot;, and Python takes care of unpacking the</span>
@ -89,9 +89,9 @@
<span class="sd">web page, doesn&#39;t handle tuples in the function parameters. And in Python 3, this</span> <span class="sd">web page, doesn&#39;t handle tuples in the function parameters. And in Python 3, this</span>
<span class="sd">syntax was removed entirely. Instead you would have to write::</span> <span class="sd">syntax was removed entirely. Instead you would have to write::</span>
<span class="sd"> def dup(stack):</span> <span class="sd"> def dup(stack):</span>
<span class="sd"> head, tail = stack</span> <span class="sd"> head, tail = stack</span>
<span class="sd"> return head, (head, tail)</span> <span class="sd"> return head, (head, tail)</span>
<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>
@ -103,138 +103,218 @@
<span class="sd">.. _cons list: https://en.wikipedia.org/wiki/Cons#Lists</span> <span class="sd">.. _cons list: https://en.wikipedia.org/wiki/Cons#Lists</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">.errors</span> <span class="kn">import</span> <span class="n">NotAListError</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span>
<div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span> <div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span>
<span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span> <span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span>
<span class="sd"> [1, 2, 3] -&gt; (1, (2, (3, ())))</span> <span class="sd"> [1, 2, 3] -&gt; (1, (2, (3, ())))</span>
<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.</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="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">el</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">el</span><span class="p">):</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span>
<span class="k">return</span> <span class="n">stack</span></div> <span class="k">return</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="iter_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.iter_stack">[docs]</a><span class="k">def</span> <span class="nf">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <div class="viewcode-block" id="iter_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.iter_stack">[docs]</a><span class="k">def</span> <span class="nf">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Iterate through the items on the stack.</span> <span class="sd">&#39;&#39;&#39;Iterate through the items on the stack.</span>
<span class="sd"> :param stack stack: A stack.</span> <span class="sd"> :param stack stack: A stack.</span>
<span class="sd"> :rtype: iterator</span> <span class="sd"> :rtype: iterator</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">while</span> <span class="n">stack</span><span class="p">:</span> <span class="k">while</span> <span class="n">stack</span><span class="p">:</span>
<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">yield</span> <span class="n">item</span></div> <span class="k">yield</span> <span class="n">item</span></div>
<div class="viewcode-block" id="stack_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.stack_to_string">[docs]</a><span class="k">def</span> <span class="nf">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <div class="viewcode-block" id="stack_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.stack_to_string">[docs]</a><span class="k">def</span> <span class="nf">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a &quot;pretty print&quot; string for a stack.</span> <span class="sd"> Return a &quot;pretty print&quot; string for a stack.</span>
<span class="sd"> The items are written right-to-left::</span> <span class="sd"> The items are written right-to-left::</span>
<span class="sd"> (top, (second, ...)) -&gt; &#39;... second top&#39;</span> <span class="sd"> (top, (second, ...)) -&gt; &#39;... second top&#39;</span>
<span class="sd"> :param stack stack: A stack.</span> <span class="sd"> :param stack stack: A stack.</span>
<span class="sd"> :rtype: str</span> <span class="sd"> :rtype: str</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">stack</span><span class="p">:</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span> <span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">stack</span><span class="p">:</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span></div> <span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span></div>
<div class="viewcode-block" id="expression_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.expression_to_string">[docs]</a><span class="k">def</span> <span class="nf">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">):</span> <div class="viewcode-block" id="expression_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.expression_to_string">[docs]</a><span class="k">def</span> <span class="nf">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a &quot;pretty print&quot; string for a expression.</span> <span class="sd"> Return a &quot;pretty print&quot; string for a expression.</span>
<span class="sd"> The items are written left-to-right::</span> <span class="sd"> The items are written left-to-right::</span>
<span class="sd"> (top, (second, ...)) -&gt; &#39;top second ...&#39;</span> <span class="sd"> (top, (second, ...)) -&gt; &#39;top second ...&#39;</span>
<span class="sd"> :param stack expression: A stack.</span> <span class="sd"> :param stack expression: A stack.</span>
<span class="sd"> :rtype: str</span> <span class="sd"> :rtype: str</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">)</span></div> <span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">)</span></div>
<span class="n">_JOY_BOOL_LITS</span> <span class="o">=</span> <span class="s1">&#39;false&#39;</span><span class="p">,</span> <span class="s1">&#39;true&#39;</span>
<span class="k">def</span> <span class="nf">_joy_repr</span><span class="p">(</span><span class="n">thing</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">thing</span><span class="p">,</span> <span class="nb">bool</span><span class="p">):</span>
<span class="k">return</span> <span class="n">_JOY_BOOL_LITS</span><span class="p">[</span><span class="n">thing</span><span class="p">]</span>
<span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="n">thing</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">):</span> <span class="k">def</span> <span class="nf">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</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">stack</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="n">stack</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">stack</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span> <span class="k">return</span> <span class="n">_joy_repr</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">stack</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;&#39;</span> <span class="c1"># shortcut</span> <span class="k">if</span> <span class="ow">not</span> <span class="n">stack</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;&#39;</span> <span class="c1"># shortcut</span>
<span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span> <span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
<span class="n">_s</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span> <span class="n">_s</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span>
<span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span> <span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="k">else</span> <span class="nb">repr</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span>
<span class="p">)</span> <span class="k">else</span> <span class="n">_joy_repr</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="p">)</span>
<div class="viewcode-block" id="concat"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.concat">[docs]</a><span class="k">def</span> <span class="nf">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span> <div class="viewcode-block" id="concat"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.concat">[docs]</a><span class="k">def</span> <span class="nf">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Concatinate quote onto expression.</span> <span class="sd">&#39;&#39;&#39;Concatinate quote onto expression.</span>
<span class="sd"> In joy [1 2] [3 4] would become [1 2 3 4].</span> <span class="sd"> In joy [1 2] [3 4] would become [1 2 3 4].</span>
<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"> :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="k">return</span> <span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">expression</span><span class="p">))</span> <span class="k">if</span> <span class="n">quote</span> <span class="k">else</span> <span class="n">expression</span></div> <span class="c1">## return (quote[0], concat(quote[1], expression)) if quote else expression</span>
<span class="c1"># Original implementation.</span> <span class="c1"># Original implementation.</span>
<span class="c1">## return list_to_stack(list(iter_stack(quote)), expression)</span> <span class="c1">## return list_to_stack(list(iter_stack(quote)), expression)</span>
<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="c1">## temp = []</span> <span class="n">temp</span> <span class="o">=</span> <span class="p">[]</span>
<span class="c1">## while quote:</span> <span class="k">while</span> <span class="n">quote</span><span class="p">:</span>
<span class="c1">## item, quote = quote</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="c1">## temp.append(item)</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="c1">## for item in reversed(temp):</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="c1">## expression = item, expression</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="c1">## return expression</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="n">expression</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">expression</span>
<span class="k">return</span> <span class="n">expression</span></div>
<div class="viewcode-block" id="dnd"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.dnd">[docs]</a><span class="k">def</span> <span class="nf">dnd</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">from_index</span><span class="p">,</span> <span class="n">to_index</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Given a stack and two indices return a rearranged stack.</span>
<span class="sd"> First remove the item at from_index and then insert it at to_index,</span>
<span class="sd"> the second index is relative to the stack after removal of the item</span>
<span class="sd"> at from_index.</span>
<span class="sd"> This function reuses all of the items and as much of the stack as it</span>
<span class="sd"> can. It&#39;s meant to be used by remote clients to support drag-n-drop</span>
<span class="sd"> rearranging of the stack from e.g. the StackListbox.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">assert</span> <span class="mi">0</span> <span class="o">&lt;=</span> <span class="n">from_index</span>
<span class="k">assert</span> <span class="mi">0</span> <span class="o">&lt;=</span> <span class="n">to_index</span>
<span class="k">if</span> <span class="n">from_index</span> <span class="o">==</span> <span class="n">to_index</span><span class="p">:</span>
<span class="k">return</span> <span class="n">stack</span>
<span class="n">head</span><span class="p">,</span> <span class="n">n</span> <span class="o">=</span> <span class="p">[],</span> <span class="n">from_index</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">break</span>
<span class="n">head</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">assert</span> <span class="nb">len</span><span class="p">(</span><span class="n">head</span><span class="p">)</span> <span class="o">==</span> <span class="n">from_index</span>
<span class="c1"># now we have two cases:</span>
<span class="n">diff</span> <span class="o">=</span> <span class="n">from_index</span> <span class="o">-</span> <span class="n">to_index</span>
<span class="k">if</span> <span class="n">diff</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="c1"># from &lt; to</span>
<span class="c1"># so the destination index is still in the stack</span>
<span class="k">while</span> <span class="n">diff</span><span class="p">:</span>
<span class="n">h</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">head</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">h</span><span class="p">)</span>
<span class="n">diff</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># from &gt; to</span>
<span class="c1"># so the destination is in the head list</span>
<span class="k">while</span> <span class="n">diff</span><span class="p">:</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="n">pop</span><span class="p">(),</span> <span class="n">stack</span>
<span class="n">diff</span> <span class="o">-=</span> <span class="mi">1</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span>
<span class="k">while</span> <span class="n">head</span><span class="p">:</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="n">pop</span><span class="p">(),</span> <span class="n">stack</span>
<span class="k">return</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="pick"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.pick">[docs]</a><span class="k">def</span> <span class="nf">pick</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <div class="viewcode-block" id="pick"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.pick">[docs]</a><span class="k">def</span> <span class="nf">pick</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return the nth item on the stack.</span> <span class="sd"> Return the nth item on the stack.</span>
<span class="sd"> :param stack stack: A stack.</span> <span class="sd"> :param stack stack: A stack.</span>
<span class="sd"> :param int n: An index into the stack.</span> <span class="sd"> :param int n: An index into the stack.</span>
<span class="sd"> :raises ValueError: if ``n`` is less than zero.</span> <span class="sd"> :raises ValueError: if ``n`` is less than zero.</span>
<span class="sd"> :raises IndexError: if ``n`` is equal to or greater than the length of ``stack``.</span> <span class="sd"> :raises IndexError: if ``n`` is equal to or greater than the length of ``stack``.</span>
<span class="sd"> :rtype: whatever</span> <span class="sd"> :rtype: whatever</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span> <span class="k">raise</span> <span class="ne">ValueError</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span> <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</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="ne">IndexError</span> <span class="k">raise</span> <span class="ne">IndexError</span>
<span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span> <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">break</span> <span class="k">break</span>
<span class="k">return</span> <span class="n">item</span></div> <span class="k">return</span> <span class="n">item</span></div>
</pre></div> </pre></div>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../../../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../../../notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../../../index.html">Documentation overview</a><ul> <li><a href="../../../index.html">Documentation overview</a><ul>
@ -244,17 +324,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../../../search.html" method="get"> <form class="search" action="../../../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -265,7 +351,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

124
docs/sphinx_docs/_build/html/_static/alabaster.css
View File

@ -1,61 +1,9 @@
@import url("basic.css"); @import url("basic.css");
/* -- page layout ----------------------------------------------------------- */ /* -- page layout ----------------------------------------------------------- */
body { body {
font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro', serif; font-family: Georgia, serif;
font-size: 17px; font-size: 17px;
background-color: #fff; background-color: #fff;
color: #000; color: #000;
@ -159,7 +107,7 @@ div.sphinxsidebarwrapper p.blurb {
div.sphinxsidebar h3, div.sphinxsidebar h3,
div.sphinxsidebar h4 { div.sphinxsidebar h4 {
font-family: 'Garamond', 'Georgia', serif; font-family: Georgia, serif;
color: #444; color: #444;
font-size: 24px; font-size: 24px;
font-weight: normal; font-weight: normal;
@ -203,7 +151,7 @@ div.sphinxsidebar ul li.toctree-l2 > a {
div.sphinxsidebar input { div.sphinxsidebar input {
border: 1px solid #CCC; border: 1px solid #CCC;
font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro', serif; font-family: Georgia, serif;
font-size: 1em; font-size: 1em;
} }
@ -218,6 +166,19 @@ div.sphinxsidebar hr {
width: 50%; width: 50%;
} }
div.sphinxsidebar .badge {
border-bottom: none;
}
div.sphinxsidebar .badge:hover {
border-bottom: none;
}
/* To address an issue with donation coming after search */
div.sphinxsidebar h3.donation {
margin-top: 10px;
}
/* -- body styles ----------------------------------------------------------- */ /* -- body styles ----------------------------------------------------------- */
a { a {
@ -236,7 +197,7 @@ div.body h3,
div.body h4, div.body h4,
div.body h5, div.body h5,
div.body h6 { div.body h6 {
font-family: 'Garamond', 'Georgia', serif; font-family: Georgia, serif;
font-weight: normal; font-weight: normal;
margin: 30px 0px 10px 0px; margin: 30px 0px 10px 0px;
padding: 0; padding: 0;
@ -277,7 +238,7 @@ div.admonition tt.xref, div.admonition code.xref, div.admonition a tt {
} }
div.admonition p.admonition-title { div.admonition p.admonition-title {
font-family: 'Garamond', 'Georgia', serif; font-family: Georgia, serif;
font-weight: normal; font-weight: normal;
font-size: 24px; font-size: 24px;
margin: 0 0 10px 0; margin: 0 0 10px 0;
@ -366,7 +327,7 @@ p.admonition-title:after {
} }
pre, tt, code { pre, tt, code {
font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace; font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
font-size: 0.9em; font-size: 0.9em;
} }
@ -690,4 +651,51 @@ table.docutils.citation, table.docutils.citation td, table.docutils.citation th
-moz-box-shadow: none; -moz-box-shadow: none;
-webkit-box-shadow: none; -webkit-box-shadow: none;
box-shadow: none; box-shadow: none;
}
/* relbar */
.related {
line-height: 30px;
width: 100%;
font-size: 0.9rem;
}
.related.top {
border-bottom: 1px solid #EEE;
margin-bottom: 20px;
}
.related.bottom {
border-top: 1px solid #EEE;
}
.related ul {
padding: 0;
margin: 0;
list-style: none;
}
.related li {
display: inline;
}
nav#rellinks {
float: right;
}
nav#rellinks li+li:before {
content: "|";
}
nav#breadcrumbs li+li:before {
content: "\00BB";
}
/* Hide certain items when printing */
@media print {
div.related {
display: none;
}
} }

334
docs/sphinx_docs/_build/html/_static/basic.css
View File

@ -4,7 +4,7 @@
* *
* Sphinx stylesheet -- basic theme. * Sphinx stylesheet -- basic theme.
* *
* :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS. * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details. * :license: BSD, see LICENSE for details.
* *
*/ */
@ -15,6 +15,12 @@ div.clearer {
clear: both; clear: both;
} }
div.section::after {
display: block;
content: '';
clear: left;
}
/* -- relbar ---------------------------------------------------------------- */ /* -- relbar ---------------------------------------------------------------- */
div.related { div.related {
@ -81,6 +87,10 @@ div.sphinxsidebar input {
font-size: 1em; font-size: 1em;
} }
div.sphinxsidebar #searchbox form.search {
overflow: hidden;
}
div.sphinxsidebar #searchbox input[type="text"] { div.sphinxsidebar #searchbox input[type="text"] {
float: left; float: left;
width: 80%; width: 80%;
@ -120,7 +130,7 @@ ul.search li a {
font-weight: bold; font-weight: bold;
} }
ul.search li div.context { ul.search li p.context {
color: #888; color: #888;
margin: 2px 0 0 30px; margin: 2px 0 0 30px;
text-align: left; text-align: left;
@ -227,6 +237,16 @@ a.headerlink {
visibility: hidden; visibility: hidden;
} }
a.brackets:before,
span.brackets > a:before{
content: "[";
}
a.brackets:after,
span.brackets > a:after {
content: "]";
}
h1:hover > a.headerlink, h1:hover > a.headerlink,
h2:hover > a.headerlink, h2:hover > a.headerlink,
h3:hover > a.headerlink, h3:hover > a.headerlink,
@ -257,19 +277,25 @@ p.rubric {
font-weight: bold; font-weight: bold;
} }
img.align-left, .figure.align-left, object.align-left { img.align-left, figure.align-left, .figure.align-left, object.align-left {
clear: left; clear: left;
float: left; float: left;
margin-right: 1em; margin-right: 1em;
} }
img.align-right, .figure.align-right, object.align-right { img.align-right, figure.align-right, .figure.align-right, object.align-right {
clear: right; clear: right;
float: right; float: right;
margin-left: 1em; margin-left: 1em;
} }
img.align-center, .figure.align-center, object.align-center { img.align-center, figure.align-center, .figure.align-center, object.align-center {
display: block;
margin-left: auto;
margin-right: auto;
}
img.align-default, figure.align-default, .figure.align-default {
display: block; display: block;
margin-left: auto; margin-left: auto;
margin-right: auto; margin-right: auto;
@ -283,30 +309,41 @@ img.align-center, .figure.align-center, object.align-center {
text-align: center; text-align: center;
} }
.align-default {
text-align: center;
}
.align-right { .align-right {
text-align: right; text-align: right;
} }
/* -- sidebars -------------------------------------------------------------- */ /* -- sidebars -------------------------------------------------------------- */
div.sidebar { div.sidebar,
aside.sidebar {
margin: 0 0 0.5em 1em; margin: 0 0 0.5em 1em;
border: 1px solid #ddb; border: 1px solid #ddb;
padding: 7px 7px 0 7px; padding: 7px;
background-color: #ffe; background-color: #ffe;
width: 40%; width: 40%;
float: right; float: right;
clear: right;
overflow-x: auto;
} }
p.sidebar-title { p.sidebar-title {
font-weight: bold; font-weight: bold;
} }
div.admonition, div.topic, blockquote {
clear: left;
}
/* -- topics ---------------------------------------------------------------- */ /* -- topics ---------------------------------------------------------------- */
div.topic { div.topic {
border: 1px solid #ccc; border: 1px solid #ccc;
padding: 7px 7px 0 7px; padding: 7px;
margin: 10px 0 10px 0; margin: 10px 0 10px 0;
} }
@ -328,10 +365,6 @@ div.admonition dt {
font-weight: bold; font-weight: bold;
} }
div.admonition dl {
margin-bottom: 0;
}
p.admonition-title { p.admonition-title {
margin: 0px 10px 5px 0px; margin: 0px 10px 5px 0px;
font-weight: bold; font-weight: bold;
@ -342,9 +375,30 @@ div.body p.centered {
margin-top: 25px; margin-top: 25px;
} }
/* -- content of sidebars/topics/admonitions -------------------------------- */
div.sidebar > :last-child,
aside.sidebar > :last-child,
div.topic > :last-child,
div.admonition > :last-child {
margin-bottom: 0;
}
div.sidebar::after,
aside.sidebar::after,
div.topic::after,
div.admonition::after,
blockquote::after {
display: block;
content: '';
clear: both;
}
/* -- tables ---------------------------------------------------------------- */ /* -- tables ---------------------------------------------------------------- */
table.docutils { table.docutils {
margin-top: 10px;
margin-bottom: 10px;
border: 0; border: 0;
border-collapse: collapse; border-collapse: collapse;
} }
@ -354,6 +408,11 @@ table.align-center {
margin-right: auto; margin-right: auto;
} }
table.align-default {
margin-left: auto;
margin-right: auto;
}
table caption span.caption-number { table caption span.caption-number {
font-style: italic; font-style: italic;
} }
@ -387,22 +446,34 @@ table.citation td {
border-bottom: none; border-bottom: none;
} }
th > :first-child,
td > :first-child {
margin-top: 0px;
}
th > :last-child,
td > :last-child {
margin-bottom: 0px;
}
/* -- figures --------------------------------------------------------------- */ /* -- figures --------------------------------------------------------------- */
div.figure { div.figure, figure {
margin: 0.5em; margin: 0.5em;
padding: 0.5em; padding: 0.5em;
} }
div.figure p.caption { div.figure p.caption, figcaption {
padding: 0.3em; padding: 0.3em;
} }
div.figure p.caption span.caption-number { div.figure p.caption span.caption-number,
figcaption span.caption-number {
font-style: italic; font-style: italic;
} }
div.figure p.caption span.caption-text { div.figure p.caption span.caption-text,
figcaption span.caption-text {
} }
/* -- field list styles ----------------------------------------------------- */ /* -- field list styles ----------------------------------------------------- */
@ -427,6 +498,74 @@ table.field-list td, table.field-list th {
hyphens: manual; hyphens: manual;
} }
/* -- hlist styles ---------------------------------------------------------- */
table.hlist {
margin: 1em 0;
}
table.hlist td {
vertical-align: top;
}
/* -- object description styles --------------------------------------------- */
.sig {
font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
}
.sig-name, code.descname {
background-color: transparent;
font-weight: bold;
}
.sig-name {
font-size: 1.1em;
}
code.descname {
font-size: 1.2em;
}
.sig-prename, code.descclassname {
background-color: transparent;
}
.optional {
font-size: 1.3em;
}
.sig-paren {
font-size: larger;
}
.sig-param.n {
font-style: italic;
}
/* C++ specific styling */
.sig-inline.c-texpr,
.sig-inline.cpp-texpr {
font-family: unset;
}
.sig.c .k, .sig.c .kt,
.sig.cpp .k, .sig.cpp .kt {
color: #0033B3;
}
.sig.c .m,
.sig.cpp .m {
color: #1750EB;
}
.sig.c .s, .sig.c .sc,
.sig.cpp .s, .sig.cpp .sc {
color: #067D17;
}
/* -- other body styles ----------------------------------------------------- */ /* -- other body styles ----------------------------------------------------- */
ol.arabic { ol.arabic {
@ -449,11 +588,78 @@ ol.upperroman {
list-style: upper-roman; list-style: upper-roman;
} }
:not(li) > ol > li:first-child > :first-child,
:not(li) > ul > li:first-child > :first-child {
margin-top: 0px;
}
:not(li) > ol > li:last-child > :last-child,
:not(li) > ul > li:last-child > :last-child {
margin-bottom: 0px;
}
ol.simple ol p,
ol.simple ul p,
ul.simple ol p,
ul.simple ul p {
margin-top: 0;
}
ol.simple > li:not(:first-child) > p,
ul.simple > li:not(:first-child) > p {
margin-top: 0;
}
ol.simple p,
ul.simple p {
margin-bottom: 0;
}
dl.footnote > dt,
dl.citation > dt {
float: left;
margin-right: 0.5em;
}
dl.footnote > dd,
dl.citation > dd {
margin-bottom: 0em;
}
dl.footnote > dd:after,
dl.citation > dd:after {
content: "";
clear: both;
}
dl.field-list {
display: grid;
grid-template-columns: fit-content(30%) auto;
}
dl.field-list > dt {
font-weight: bold;
word-break: break-word;
padding-left: 0.5em;
padding-right: 5px;
}
dl.field-list > dt:after {
content: ":";
}
dl.field-list > dd {
padding-left: 0.5em;
margin-top: 0em;
margin-left: 0em;
margin-bottom: 0em;
}
dl { dl {
margin-bottom: 15px; margin-bottom: 15px;
} }
dd p { dd > :first-child {
margin-top: 0px; margin-top: 0px;
} }
@ -467,6 +673,11 @@ dd {
margin-left: 30px; margin-left: 30px;
} }
dl > dd:last-child,
dl > dd:last-child > :last-child {
margin-bottom: 0;
}
dt:target, span.highlighted { dt:target, span.highlighted {
background-color: #fbe54e; background-color: #fbe54e;
} }
@ -480,14 +691,6 @@ dl.glossary dt {
font-size: 1.1em; font-size: 1.1em;
} }
.optional {
font-size: 1.3em;
}
.sig-paren {
font-size: larger;
}
.versionmodified { .versionmodified {
font-style: italic; font-style: italic;
} }
@ -526,6 +729,13 @@ dl.glossary dt {
font-style: oblique; font-style: oblique;
} }
.classifier:before {
font-style: normal;
margin: 0 0.5em;
content: ":";
display: inline-block;
}
abbr, acronym { abbr, acronym {
border-bottom: dotted 1px; border-bottom: dotted 1px;
cursor: help; cursor: help;
@ -538,6 +748,10 @@ pre {
overflow-y: hidden; /* fixes display issues on Chrome browsers */ overflow-y: hidden; /* fixes display issues on Chrome browsers */
} }
pre, div[class*="highlight-"] {
clear: both;
}
span.pre { span.pre {
-moz-hyphens: none; -moz-hyphens: none;
-ms-hyphens: none; -ms-hyphens: none;
@ -545,22 +759,57 @@ span.pre {
hyphens: none; hyphens: none;
} }
div[class*="highlight-"] {
margin: 1em 0;
}
td.linenos pre { td.linenos pre {
padding: 5px 0px;
border: 0; border: 0;
background-color: transparent; background-color: transparent;
color: #aaa; color: #aaa;
} }
table.highlighttable { table.highlighttable {
margin-left: 0.5em; display: block;
}
table.highlighttable tbody {
display: block;
}
table.highlighttable tr {
display: flex;
} }
table.highlighttable td { table.highlighttable td {
padding: 0 0.5em 0 0.5em; margin: 0;
padding: 0;
}
table.highlighttable td.linenos {
padding-right: 0.5em;
}
table.highlighttable td.code {
flex: 1;
overflow: hidden;
}
.highlight .hll {
display: block;
}
div.highlight pre,
table.highlighttable pre {
margin: 0;
}
div.code-block-caption + div {
margin-top: 0;
} }
div.code-block-caption { div.code-block-caption {
margin-top: 1em;
padding: 2px 5px; padding: 2px 5px;
font-size: small; font-size: small;
} }
@ -569,8 +818,14 @@ div.code-block-caption code {
background-color: transparent; background-color: transparent;
} }
div.code-block-caption + div > div.highlight > pre { table.highlighttable td.linenos,
margin-top: 0; span.linenos,
div.highlight span.gp { /* gp: Generic.Prompt */
user-select: none;
-webkit-user-select: text; /* Safari fallback only */
-webkit-user-select: none; /* Chrome/Safari */
-moz-user-select: none; /* Firefox */
-ms-user-select: none; /* IE10+ */
} }
div.code-block-caption span.caption-number { div.code-block-caption span.caption-number {
@ -582,21 +837,7 @@ div.code-block-caption span.caption-text {
} }
div.literal-block-wrapper { div.literal-block-wrapper {
padding: 1em 1em 0; margin: 1em 0;
}
div.literal-block-wrapper div.highlight {
margin: 0;
}
code.descname {
background-color: transparent;
font-weight: bold;
font-size: 1.2em;
}
code.descclassname {
background-color: transparent;
} }
code.xref, a code { code.xref, a code {
@ -637,8 +878,7 @@ span.eqno {
} }
span.eqno a.headerlink { span.eqno a.headerlink {
position: relative; position: absolute;
left: 0px;
z-index: 1; z-index: 1;
} }

30
docs/sphinx_docs/_build/html/_static/doctools.js
View File

@ -4,7 +4,7 @@
* *
* Sphinx JavaScript utilities for all documentation. * Sphinx JavaScript utilities for all documentation.
* *
* :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS. * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details. * :license: BSD, see LICENSE for details.
* *
*/ */
@ -29,9 +29,14 @@ if (!window.console || !console.firebug) {
/** /**
* small helper function to urldecode strings * small helper function to urldecode strings
*
* See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
*/ */
jQuery.urldecode = function(x) { jQuery.urldecode = function(x) {
return decodeURIComponent(x).replace(/\+/g, ' '); if (!x) {
return x
}
return decodeURIComponent(x.replace(/\+/g, ' '));
}; };
/** /**
@ -87,14 +92,13 @@ jQuery.fn.highlightText = function(text, className) {
node.nextSibling)); node.nextSibling));
node.nodeValue = val.substr(0, pos); node.nodeValue = val.substr(0, pos);
if (isInSVG) { if (isInSVG) {
var bbox = span.getBBox();
var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
rect.x.baseVal.value = bbox.x; var bbox = node.parentElement.getBBox();
rect.x.baseVal.value = bbox.x;
rect.y.baseVal.value = bbox.y; rect.y.baseVal.value = bbox.y;
rect.width.baseVal.value = bbox.width; rect.width.baseVal.value = bbox.width;
rect.height.baseVal.value = bbox.height; rect.height.baseVal.value = bbox.height;
rect.setAttribute('class', className); rect.setAttribute('class', className);
var parentOfText = node.parentNode.parentNode;
addItems.push({ addItems.push({
"parent": node.parentNode, "parent": node.parentNode,
"target": rect}); "target": rect});
@ -150,7 +154,9 @@ var Documentation = {
this.fixFirefoxAnchorBug(); this.fixFirefoxAnchorBug();
this.highlightSearchWords(); this.highlightSearchWords();
this.initIndexTable(); this.initIndexTable();
if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) {
this.initOnKeyListeners();
}
}, },
/** /**
@ -282,10 +288,12 @@ var Documentation = {
}, },
initOnKeyListeners: function() { initOnKeyListeners: function() {
$(document).keyup(function(event) { $(document).keydown(function(event) {
var activeElementType = document.activeElement.tagName; var activeElementType = document.activeElement.tagName;
// don't navigate when in search box or textarea // don't navigate when in search box, textarea, dropdown or button
if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT'
&& activeElementType !== 'BUTTON' && !event.altKey && !event.ctrlKey && !event.metaKey
&& !event.shiftKey) {
switch (event.keyCode) { switch (event.keyCode) {
case 37: // left case 37: // left
var prevHref = $('link[rel="prev"]').prop('href'); var prevHref = $('link[rel="prev"]').prop('href');
@ -293,12 +301,14 @@ var Documentation = {
window.location.href = prevHref; window.location.href = prevHref;
return false; return false;
} }
break;
case 39: // right case 39: // right
var nextHref = $('link[rel="next"]').prop('href'); var nextHref = $('link[rel="next"]').prop('href');
if (nextHref) { if (nextHref) {
window.location.href = nextHref; window.location.href = nextHref;
return false; return false;
} }
break;
} }
} }
}); });
@ -310,4 +320,4 @@ _ = Documentation.gettext;
$(document).ready(function() { $(document).ready(function() {
Documentation.init(); Documentation.init();
}); });

7
docs/sphinx_docs/_build/html/_static/documentation_options.js
View File

@ -1,9 +1,12 @@
var DOCUMENTATION_OPTIONS = { var DOCUMENTATION_OPTIONS = {
URL_ROOT: '', URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
VERSION: '0.4.1', VERSION: '0.4.1',
LANGUAGE: 'None', LANGUAGE: 'None',
COLLAPSE_INDEX: false, COLLAPSE_INDEX: false,
BUILDER: 'html',
FILE_SUFFIX: '.html', FILE_SUFFIX: '.html',
LINK_SUFFIX: '.html',
HAS_SOURCE: true, HAS_SOURCE: true,
SOURCELINK_SUFFIX: '.txt' SOURCELINK_SUFFIX: '.txt',
NAVIGATION_WITH_KEYS: false
}; };

6
docs/sphinx_docs/_build/html/_static/jquery.js vendored
View File

File diff suppressed because one or more lines are too long

7
docs/sphinx_docs/_build/html/_static/pygments.css
View File

@ -1,5 +1,10 @@
pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc } .highlight .hll { background-color: #ffffcc }
.highlight { background: #eeffcc; } .highlight { background: #eeffcc; }
.highlight .c { color: #408090; font-style: italic } /* Comment */ .highlight .c { color: #408090; font-style: italic } /* Comment */
.highlight .err { border: 1px solid #FF0000 } /* Error */ .highlight .err { border: 1px solid #FF0000 } /* Error */
.highlight .k { color: #007020; font-weight: bold } /* Keyword */ .highlight .k { color: #007020; font-weight: bold } /* Keyword */

464
docs/sphinx_docs/_build/html/_static/searchtools.js
View File

@ -1,331 +1,54 @@
/* /*
* searchtools.js_t * searchtools.js
* ~~~~~~~~~~~~~~~~ * ~~~~~~~~~~~~~~~~
* *
* Sphinx JavaScript utilities for the full-text search. * Sphinx JavaScript utilities for the full-text search.
* *
* :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS. * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details. * :license: BSD, see LICENSE for details.
* *
*/ */
if (!Scorer) {
/**
* Simple result scoring code.
*/
var Scorer = {
// Implement the following function to further tweak the score for each result
// The function takes a result array [filename, title, anchor, descr, score]
// and returns the new score.
/*
score: function(result) {
return result[4];
},
*/
/* Non-minified version JS is _stemmer.js if file is provided */ // query matches the full name of an object
/** objNameMatch: 11,
* Porter Stemmer // or matches in the last dotted part of the object name
*/ objPartialMatch: 6,
var Stemmer = function() { // Additive scores depending on the priority of the object
objPrio: {0: 15, // used to be importantResults
1: 5, // used to be objectResults
2: -5}, // used to be unimportantResults
// Used when the priority is not in the mapping.
objPrioDefault: 0,
var step2list = { // query found in title
ational: 'ate', title: 15,
tional: 'tion', partialTitle: 7,
enci: 'ence', // query found in terms
anci: 'ance', term: 5,
izer: 'ize', partialTerm: 2
bli: 'ble',
alli: 'al',
entli: 'ent',
eli: 'e',
ousli: 'ous',
ization: 'ize',
ation: 'ate',
ator: 'ate',
alism: 'al',
iveness: 'ive',
fulness: 'ful',
ousness: 'ous',
aliti: 'al',
iviti: 'ive',
biliti: 'ble',
logi: 'log'
}; };
}
var step3list = { if (!splitQuery) {
icate: 'ic', function splitQuery(query) {
ative: '', return query.split(/\s+/);
alize: 'al',
iciti: 'ic',
ical: 'ic',
ful: '',
ness: ''
};
var c = "[^aeiou]"; // consonant
var v = "[aeiouy]"; // vowel
var C = c + "[^aeiouy]*"; // consonant sequence
var V = v + "[aeiou]*"; // vowel sequence
var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
var s_v = "^(" + C + ")?" + v; // vowel in stem
this.stemWord = function (w) {
var stem;
var suffix;
var firstch;
var origword = w;
if (w.length < 3)
return w;
var re;
var re2;
var re3;
var re4;
firstch = w.substr(0,1);
if (firstch == "y")
w = firstch.toUpperCase() + w.substr(1);
// Step 1a
re = /^(.+?)(ss|i)es$/;
re2 = /^(.+?)([^s])s$/;
if (re.test(w))
w = w.replace(re,"$1$2");
else if (re2.test(w))
w = w.replace(re2,"$1$2");
// Step 1b
re = /^(.+?)eed$/;
re2 = /^(.+?)(ed|ing)$/;
if (re.test(w)) {
var fp = re.exec(w);
re = new RegExp(mgr0);
if (re.test(fp[1])) {
re = /.$/;
w = w.replace(re,"");
}
}
else if (re2.test(w)) {
var fp = re2.exec(w);
stem = fp[1];
re2 = new RegExp(s_v);
if (re2.test(stem)) {
w = stem;
re2 = /(at|bl|iz)$/;
re3 = new RegExp("([^aeiouylsz])\\1$");
re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
if (re2.test(w))
w = w + "e";
else if (re3.test(w)) {
re = /.$/;
w = w.replace(re,"");
}
else if (re4.test(w))
w = w + "e";
}
}
// Step 1c
re = /^(.+?)y$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(s_v);
if (re.test(stem))
w = stem + "i";
}
// Step 2
re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
suffix = fp[2];
re = new RegExp(mgr0);
if (re.test(stem))
w = stem + step2list[suffix];
}
// Step 3
re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
suffix = fp[2];
re = new RegExp(mgr0);
if (re.test(stem))
w = stem + step3list[suffix];
}
// Step 4
re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
re2 = /^(.+?)(s|t)(ion)$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(mgr1);
if (re.test(stem))
w = stem;
}
else if (re2.test(w)) {
var fp = re2.exec(w);
stem = fp[1] + fp[2];
re2 = new RegExp(mgr1);
if (re2.test(stem))
w = stem;
}
// Step 5
re = /^(.+?)e$/;
if (re.test(w)) {
var fp = re.exec(w);
stem = fp[1];
re = new RegExp(mgr1);
re2 = new RegExp(meq1);
re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
w = stem;
}
re = /ll$/;
re2 = new RegExp(mgr1);
if (re.test(w) && re2.test(w)) {
re = /.$/;
w = w.replace(re,"");
}
// and turn initial Y back to y
if (firstch == "y")
w = firstch.toLowerCase() + w.substr(1);
return w;
} }
} }
/**
* Simple result scoring code.
*/
var Scorer = {
// Implement the following function to further tweak the score for each result
// The function takes a result array [filename, title, anchor, descr, score]
// and returns the new score.
/*
score: function(result) {
return result[4];
},
*/
// query matches the full name of an object
objNameMatch: 11,
// or matches in the last dotted part of the object name
objPartialMatch: 6,
// Additive scores depending on the priority of the object
objPrio: {0: 15, // used to be importantResults
1: 5, // used to be objectResults
2: -5}, // used to be unimportantResults
// Used when the priority is not in the mapping.
objPrioDefault: 0,
// query found in title
title: 15,
// query found in terms
term: 5
};
var splitChars = (function() {
var result = {};
var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
var i, j, start, end;
for (i = 0; i < singles.length; i++) {
result[singles[i]] = true;
}
var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
[722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
[1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
[1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
[1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
[2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
[2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
[2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
[2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
[2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
[2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
[2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
[3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
[3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
[3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
[3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
[3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
[3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
[4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
[4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
[4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
[4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
[5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
[6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
[6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
[6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
[6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
[7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
[7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
[8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
[8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
[8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
[10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
[11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
[12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
[12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
[12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
[19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
[42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
[42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
[43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
[43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
[43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
[43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
[44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
[57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
[64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
[65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
[65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
for (i = 0; i < ranges.length; i++) {
start = ranges[i][0];
end = ranges[i][1];
for (j = start; j <= end; j++) {
result[j] = true;
}
}
return result;
})();
function splitQuery(query) {
var result = [];
var start = -1;
for (var i = 0; i < query.length; i++) {
if (splitChars[query.charCodeAt(i)]) {
if (start !== -1) {
result.push(query.slice(start, i));
start = -1;
}
} else if (start === -1) {
start = i;
}
}
if (start !== -1) {
result.push(query.slice(start));
}
return result;
}
/** /**
* Search Module * Search Module
*/ */
@ -335,6 +58,19 @@ var Search = {
_queued_query : null, _queued_query : null,
_pulse_status : -1, _pulse_status : -1,
htmlToText : function(htmlString) {
var virtualDocument = document.implementation.createHTMLDocument('virtual');
var htmlElement = $(htmlString, virtualDocument);
htmlElement.find('.headerlink').remove();
docContent = htmlElement.find('[role=main]')[0];
if(docContent === undefined) {
console.warn("Content block not found. Sphinx search tries to obtain it " +
"via '[role=main]'. Could you check your theme or template.");
return "";
}
return docContent.textContent || docContent.innerText;
},
init : function() { init : function() {
var params = $.getQueryParameters(); var params = $.getQueryParameters();
if (params.q) { if (params.q) {
@ -399,7 +135,7 @@ var Search = {
this.out = $('#search-results'); this.out = $('#search-results');
this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out); this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
this.dots = $('<span></span>').appendTo(this.title); this.dots = $('<span></span>').appendTo(this.title);
this.status = $('<p style="display: none"></p>').appendTo(this.out); this.status = $('<p class="search-summary">&nbsp;</p>').appendTo(this.out);
this.output = $('<ul class="search"/>').appendTo(this.out); this.output = $('<ul class="search"/>').appendTo(this.out);
$('#search-progress').text(_('Preparing search...')); $('#search-progress').text(_('Preparing search...'));
@ -417,7 +153,6 @@ var Search = {
*/ */
query : function(query) { query : function(query) {
var i; var i;
var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"];
// stem the searchterms and add them to the correct list // stem the searchterms and add them to the correct list
var stemmer = new Stemmer(); var stemmer = new Stemmer();
@ -431,8 +166,7 @@ var Search = {
objectterms.push(tmp[i].toLowerCase()); objectterms.push(tmp[i].toLowerCase());
} }
if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i].match(/^\d+$/) || if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i] === "") {
tmp[i] === "") {
// skip this "word" // skip this "word"
continue; continue;
} }
@ -514,8 +248,10 @@ var Search = {
// results left, load the summary and display it // results left, load the summary and display it
if (results.length) { if (results.length) {
var item = results.pop(); var item = results.pop();
var listItem = $('<li style="display:none"></li>'); var listItem = $('<li></li>');
if (DOCUMENTATION_OPTIONS.FILE_SUFFIX === '') { var requestUrl = "";
var linkUrl = "";
if (DOCUMENTATION_OPTIONS.BUILDER === 'dirhtml') {
// dirhtml builder // dirhtml builder
var dirname = item[0] + '/'; var dirname = item[0] + '/';
if (dirname.match(/\/index\/$/)) { if (dirname.match(/\/index\/$/)) {
@ -523,44 +259,45 @@ var Search = {
} else if (dirname == 'index/') { } else if (dirname == 'index/') {
dirname = ''; dirname = '';
} }
listItem.append($('<a/>').attr('href', requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + dirname;
DOCUMENTATION_OPTIONS.URL_ROOT + dirname + linkUrl = requestUrl;
highlightstring + item[2]).html(item[1]));
} else { } else {
// normal html builders // normal html builders
listItem.append($('<a/>').attr('href', requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX;
item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX + linkUrl = item[0] + DOCUMENTATION_OPTIONS.LINK_SUFFIX;
highlightstring + item[2]).html(item[1]));
} }
listItem.append($('<a/>').attr('href',
linkUrl +
highlightstring + item[2]).html(item[1]));
if (item[3]) { if (item[3]) {
listItem.append($('<span> (' + item[3] + ')</span>')); listItem.append($('<span> (' + item[3] + ')</span>'));
Search.output.append(listItem); Search.output.append(listItem);
listItem.slideDown(5, function() { setTimeout(function() {
displayNextItem(); displayNextItem();
}); }, 5);
} else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) { } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
var suffix = DOCUMENTATION_OPTIONS.SOURCELINK_SUFFIX; $.ajax({url: requestUrl,
if (suffix === undefined) {
suffix = '.txt';
}
$.ajax({url: DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' + item[5] + (item[5].slice(-suffix.length) === suffix ? '' : suffix),
dataType: "text", dataType: "text",
complete: function(jqxhr, textstatus) { complete: function(jqxhr, textstatus) {
var data = jqxhr.responseText; var data = jqxhr.responseText;
if (data !== '' && data !== undefined) { if (data !== '' && data !== undefined) {
listItem.append(Search.makeSearchSummary(data, searchterms, hlterms)); var summary = Search.makeSearchSummary(data, searchterms, hlterms);
if (summary) {
listItem.append(summary);
}
} }
Search.output.append(listItem); Search.output.append(listItem);
listItem.slideDown(5, function() { setTimeout(function() {
displayNextItem(); displayNextItem();
}); }, 5);
}}); }});
} else { } else {
// no source available, just display title // no source available, just display title
Search.output.append(listItem); Search.output.append(listItem);
listItem.slideDown(5, function() { setTimeout(function() {
displayNextItem(); displayNextItem();
}); }, 5);
} }
} }
// search finished, update title and status message // search finished, update title and status message
@ -591,20 +328,22 @@ var Search = {
var results = []; var results = [];
for (var prefix in objects) { for (var prefix in objects) {
for (var name in objects[prefix]) { for (var iMatch = 0; iMatch != objects[prefix].length; ++iMatch) {
var match = objects[prefix][iMatch];
var name = match[4];
var fullname = (prefix ? prefix + '.' : '') + name; var fullname = (prefix ? prefix + '.' : '') + name;
if (fullname.toLowerCase().indexOf(object) > -1) { var fullnameLower = fullname.toLowerCase()
if (fullnameLower.indexOf(object) > -1) {
var score = 0; var score = 0;
var parts = fullname.split('.'); var parts = fullnameLower.split('.');
// check for different match types: exact matches of full name or // check for different match types: exact matches of full name or
// "last name" (i.e. last dotted part) // "last name" (i.e. last dotted part)
if (fullname == object || parts[parts.length - 1] == object) { if (fullnameLower == object || parts[parts.length - 1] == object) {
score += Scorer.objNameMatch; score += Scorer.objNameMatch;
// matches in last name // matches in last name
} else if (parts[parts.length - 1].indexOf(object) > -1) { } else if (parts[parts.length - 1].indexOf(object) > -1) {
score += Scorer.objPartialMatch; score += Scorer.objPartialMatch;
} }
var match = objects[prefix][name];
var objname = objnames[match[1]][2]; var objname = objnames[match[1]][2];
var title = titles[match[0]]; var title = titles[match[0]];
// If more than one term searched for, we require other words to be // If more than one term searched for, we require other words to be
@ -644,6 +383,13 @@ var Search = {
return results; return results;
}, },
/**
* See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
*/
escapeRegExp : function(string) {
return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
},
/** /**
* search for full-text terms in the index * search for full-text terms in the index
*/ */
@ -665,6 +411,20 @@ var Search = {
{files: terms[word], score: Scorer.term}, {files: terms[word], score: Scorer.term},
{files: titleterms[word], score: Scorer.title} {files: titleterms[word], score: Scorer.title}
]; ];
// add support for partial matches
if (word.length > 2) {
var word_regex = this.escapeRegExp(word);
for (var w in terms) {
if (w.match(word_regex) && !terms[word]) {
_o.push({files: terms[w], score: Scorer.partialTerm})
}
}
for (var w in titleterms) {
if (w.match(word_regex) && !titleterms[word]) {
_o.push({files: titleterms[w], score: Scorer.partialTitle})
}
}
}
// no match but word was a required one // no match but word was a required one
if ($u.every(_o, function(o){return o.files === undefined;})) { if ($u.every(_o, function(o){return o.files === undefined;})) {
@ -684,7 +444,7 @@ var Search = {
for (j = 0; j < _files.length; j++) { for (j = 0; j < _files.length; j++) {
file = _files[j]; file = _files[j];
if (!(file in scoreMap)) if (!(file in scoreMap))
scoreMap[file] = {} scoreMap[file] = {};
scoreMap[file][word] = o.score; scoreMap[file][word] = o.score;
} }
}); });
@ -692,7 +452,7 @@ var Search = {
// create the mapping // create the mapping
for (j = 0; j < files.length; j++) { for (j = 0; j < files.length; j++) {
file = files[j]; file = files[j];
if (file in fileMap) if (file in fileMap && fileMap[file].indexOf(word) === -1)
fileMap[file].push(word); fileMap[file].push(word);
else else
fileMap[file] = [word]; fileMap[file] = [word];
@ -704,8 +464,12 @@ var Search = {
var valid = true; var valid = true;
// check if all requirements are matched // check if all requirements are matched
if (fileMap[file].length != searchterms.length) var filteredTermCount = // as search terms with length < 3 are discarded: ignore
continue; searchterms.filter(function(term){return term.length > 2}).length
if (
fileMap[file].length != searchterms.length &&
fileMap[file].length != filteredTermCount
) continue;
// ensure that none of the excluded terms is in the search result // ensure that none of the excluded terms is in the search result
for (i = 0; i < excluded.length; i++) { for (i = 0; i < excluded.length; i++) {
@ -736,7 +500,11 @@ var Search = {
* words. the first one is used to find the occurrence, the * words. the first one is used to find the occurrence, the
* latter for highlighting it. * latter for highlighting it.
*/ */
makeSearchSummary : function(text, keywords, hlwords) { makeSearchSummary : function(htmlText, keywords, hlwords) {
var text = Search.htmlToText(htmlText);
if (text == "") {
return null;
}
var textLower = text.toLowerCase(); var textLower = text.toLowerCase();
var start = 0; var start = 0;
$.each(keywords, function() { $.each(keywords, function() {
@ -748,7 +516,7 @@ var Search = {
var excerpt = ((start > 0) ? '...' : '') + var excerpt = ((start > 0) ? '...' : '') +
$.trim(text.substr(start, 240)) + $.trim(text.substr(start, 240)) +
((start + 240 - text.length) ? '...' : ''); ((start + 240 - text.length) ? '...' : '');
var rv = $('<div class="context"></div>').text(excerpt); var rv = $('<p class="context"></p>').text(excerpt);
$.each(hlwords, function() { $.each(hlwords, function() {
rv = rv.highlightText(this, 'highlighted'); rv = rv.highlightText(this, 'highlighted');
}); });
@ -758,4 +526,4 @@ var Search = {
$(document).ready(function() { $(document).ready(function() {
Search.init(); Search.init();
}); });

37
docs/sphinx_docs/_build/html/_static/underscore.js
View File

File diff suppressed because one or more lines are too long

148
docs/sphinx_docs/_build/html/genindex.html
View File

@ -1,20 +1,17 @@
<!DOCTYPE html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Index &#8212; Thun 0.4.1 documentation</title> <title>Index &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="#" /> <link rel="index" title="Index" href="#" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
@ -29,6 +26,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
@ -129,10 +128,12 @@
<li><a href="library.html#joy.library.dipdd">dipdd() (in module joy.library)</a> <li><a href="library.html#joy.library.dipdd">dipdd() (in module joy.library)</a>
</li> </li>
<li><a href="library.html#joy.library.disenstacken">disenstacken() (in module joy.library)</a> <li><a href="library.html#joy.library.disenstacken">disenstacken() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.divmod_">divmod_() (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.divmod_">divmod_() (in module joy.library)</a> <li><a href="stack.html#joy.utils.stack.dnd">dnd() (in module joy.utils.stack)</a>
</li> </li>
<li><a href="library.html#joy.library.drop">drop() (in module joy.library)</a> <li><a href="library.html#joy.library.drop">drop() (in module joy.library)</a>
</li> </li>
@ -204,13 +205,15 @@
</li> </li>
<li><a href="library.html#joy.library.infra">infra() (in module joy.library)</a> <li><a href="library.html#joy.library.infra">infra() (in module joy.library)</a>
</li> </li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.initialize">initialize() (in module joy.library)</a> <li><a href="library.html#joy.library.initialize">initialize() (in module joy.library)</a>
</li> </li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.inscribe">inscribe() (in module joy.library)</a> <li><a href="library.html#joy.library.inscribe">inscribe() (in module joy.library)</a>
</li> </li>
<li><a href="library.html#joy.library.inscribe_">inscribe_() (in module joy.library)</a> <li><a href="library.html#joy.library.inscribe_">inscribe_() (in module joy.library)</a>
</li>
<li><a href="joy.html#joy.joy.interp">interp() (in module joy.joy)</a>
</li> </li>
<li><a href="stack.html#joy.utils.stack.iter_stack">iter_stack() (in module joy.utils.stack)</a> <li><a href="stack.html#joy.utils.stack.iter_stack">iter_stack() (in module joy.utils.stack)</a>
</li> </li>
@ -222,20 +225,50 @@
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="joy.html#joy.joy.joy">joy() (in module joy.joy)</a> <li><a href="joy.html#joy.joy.joy">joy() (in module joy.joy)</a>
</li> </li>
<li><a href="joy.html#module-joy.joy">joy.joy (module)</a> <li>
joy.joy
<ul>
<li><a href="joy.html#module-joy.joy">module</a>
</li> </li>
<li><a href="library.html#module-joy.library">joy.library (module)</a> </ul></li>
<li>
joy.library
<ul>
<li><a href="library.html#module-joy.library">module</a>
</li> </li>
</ul></li>
<li>
joy.parser
<ul>
<li><a href="parser.html#module-joy.parser">module</a>
</li>
</ul></li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="parser.html#module-joy.parser">joy.parser (module)</a> <li>
joy.utils.generated_library
<ul>
<li><a href="library.html#module-joy.utils.generated_library">module</a>
</li> </li>
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a> </ul></li>
<li>
joy.utils.pretty_print
<ul>
<li><a href="pretty.html#module-joy.utils.pretty_print">module</a>
</li> </li>
<li><a href="pretty.html#module-joy.utils.pretty_print">joy.utils.pretty_print (module)</a> </ul></li>
</li> <li>
<li><a href="stack.html#module-joy.utils.stack">joy.utils.stack (module)</a> joy.utils.stack
<ul>
<li><a href="stack.html#module-joy.utils.stack">module</a>
</li> </li>
</ul></li>
</ul></td> </ul></td>
</tr></table> </tr></table>
@ -256,12 +289,27 @@
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.map_">map_() (in module joy.library)</a> <li><a href="library.html#joy.library.map_">map_() (in module joy.library)</a>
</li> </li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.max_">max_() (in module joy.library)</a> <li><a href="library.html#joy.library.max_">max_() (in module joy.library)</a>
</li> </li>
<li><a href="library.html#joy.library.min_">min_() (in module joy.library)</a> <li><a href="library.html#joy.library.min_">min_() (in module joy.library)</a>
</li> </li>
<li>
module
<ul>
<li><a href="joy.html#module-joy.joy">joy.joy</a>
</li>
<li><a href="library.html#module-joy.library">joy.library</a>
</li>
<li><a href="parser.html#module-joy.parser">joy.parser</a>
</li>
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library</a>
</li>
<li><a href="pretty.html#module-joy.utils.pretty_print">joy.utils.pretty_print</a>
</li>
<li><a href="stack.html#module-joy.utils.stack">joy.utils.stack</a>
</li>
</ul></li>
</ul></td> </ul></td>
</tr></table> </tr></table>
@ -404,11 +452,13 @@
</li> </li>
<li><a href="library.html#joy.utils.generated_library.uncons">uncons() (in module joy.utils.generated_library)</a> <li><a href="library.html#joy.utils.generated_library.uncons">uncons() (in module joy.utils.generated_library)</a>
</li> </li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.unique">unique() (in module joy.library)</a> <li><a href="library.html#joy.library.unique">unique() (in module joy.library)</a>
</li> </li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.utils.generated_library.unit">unit() (in module joy.utils.generated_library)</a> <li><a href="library.html#joy.utils.generated_library.unit">unit() (in module joy.utils.generated_library)</a>
</li>
<li><a href="joy.html#joy.joy.UnknownSymbolError">UnknownSymbolError</a>
</li> </li>
<li><a href="library.html#joy.utils.generated_library.unswons">unswons() (in module joy.utils.generated_library)</a> <li><a href="library.html#joy.utils.generated_library.unswons">unswons() (in module joy.utils.generated_library)</a>
</li> </li>
@ -458,10 +508,34 @@
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="index.html">Documentation overview</a><ul> <li><a href="index.html">Documentation overview</a><ul>
@ -469,17 +543,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -490,7 +570,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

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

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Thun 0.4.1 Documentation &#8212; Thun 0.4.1 documentation</title> <title>Thun 0.4.1 Documentation &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Thun: Joy in Python" href="notebooks/Intro.html" /> <link rel="next" title="Thun: Joy in Python" href="notebooks/Intro.html" />
@ -29,9 +28,11 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="thun-release-documentation"> <section id="thun-release-documentation">
<h1>Thun 0.4.1 Documentation<a class="headerlink" href="#thun-release-documentation" title="Permalink to this headline"></a></h1> <h1>Thun 0.4.1 Documentation<a class="headerlink" href="#thun-release-documentation" title="Permalink to this headline"></a></h1>
<p>Thun is dialect of Joy written in Python.</p> <p>Thun is dialect of Joy written in Python.</p>
<p><a class="reference external" href="https://en.wikipedia.org/wiki/Joy_(programming_language)">Joy</a> is a programming language created by Manfred von Thun that is easy to <p><a class="reference external" href="https://en.wikipedia.org/wiki/Joy_(programming_language)">Joy</a> is a programming language created by Manfred von Thun that is easy to
@ -43,17 +44,17 @@ between Thun and the originals, other than being written in Python, is
that it works by the “Continuation-Passing Style”.</p> that it works by the “Continuation-Passing Style”.</p>
<p>Joy is:</p> <p>Joy is:</p>
<ul class="simple"> <ul class="simple">
<li><a class="reference external" href="https://en.wikipedia.org/wiki/Purely_functional_programming">Purely Functional</a></li> <li><p><a class="reference external" href="https://en.wikipedia.org/wiki/Purely_functional_programming">Purely Functional</a></p></li>
<li><a class="reference external" href="https://en.wikipedia.org/wiki/Stack-oriented_programming_language">Stack-based</a></li> <li><p><a class="reference external" href="https://en.wikipedia.org/wiki/Stack-oriented_programming_language">Stack-based</a></p></li>
<li><a class="reference external" href="https://en.wikipedia.org/wiki/Concatenative_programming_language">Concatinative</a> ( See also <a class="reference external" href="http://www.concatenative.org/wiki/view/Concatenative%20language">concatenative.org</a>)</li> <li><p><a class="reference external" href="https://en.wikipedia.org/wiki/Concatenative_programming_language">Concatinative</a> ( See also <a class="reference external" href="http://www.concatenative.org/wiki/view/Concatenative%20language">concatenative.org</a>)</p></li>
<li><a class="reference internal" href="notebooks/Categorical.html"><span class="doc">Categorical</span></a></li> <li><p><a class="reference internal" href="notebooks/Categorical.html"><span class="doc">Categorical</span></a></p></li>
</ul> </ul>
<p>I hope that this package is useful in the sense that it provides an <p>I hope that this package is useful in the sense that it provides an
additional joy interpreter (the binary in the archive from La Trobe seems additional joy interpreter (the binary in the archive from La Trobe seems
to run just fine on my modern Linux machine!) But I also hope that you to run just fine on my modern Linux machine!) But I also hope that you
can read and understand the Python code and play with the implementation can read and understand the Python code and play with the implementation
itself.</p> itself.</p>
<div class="section" id="quick-start"> <section id="quick-start">
<h2>Quick Start<a class="headerlink" href="#quick-start" title="Permalink to this headline"></a></h2> <h2>Quick Start<a class="headerlink" href="#quick-start" title="Permalink to this headline"></a></h2>
<p>Install from <a class="reference external" href="https://pypi.org/project/Thun/">PyPI</a> in the usual way:</p> <p>Install from <a class="reference external" href="https://pypi.org/project/Thun/">PyPI</a> in the usual way:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>$ pip install Thun <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>$ pip install Thun
@ -64,17 +65,17 @@ itself.</p>
</pre></div> </pre></div>
</div> </div>
<p>Continue with <a class="reference internal" href="notebooks/Intro.html"><span class="doc">the introduction</span></a>.</p> <p>Continue with <a class="reference internal" href="notebooks/Intro.html"><span class="doc">the introduction</span></a>.</p>
</div> </section>
<div class="section" id="project-hosted-on-osdn"> <section id="project-hosted-on-osdn">
<h2>Project Hosted on <a class="reference external" href="https://osdn.net/projects/joypy/">OSDN</a><a class="headerlink" href="#project-hosted-on-osdn" title="Permalink to this headline"></a></h2> <h2>Project Hosted on <a class="reference external" href="https://osdn.net/projects/joypy/">OSDN</a><a class="headerlink" href="#project-hosted-on-osdn" title="Permalink to this headline"></a></h2>
<ul class="simple"> <ul class="simple">
<li><a class="reference external" href="https://osdn.net/projects/joypy/scm/hg/Joypy/tree/tip/">Source Repository</a> (Mercurial)</li> <li><p><a class="reference external" href="https://osdn.net/projects/joypy/scm/hg/Joypy/tree/tip/">Source Repository</a> (Mercurial)</p></li>
<li><a class="reference external" href="https://osdn.net/projects/joypy/ticket/">Bug tracker</a></li> <li><p><a class="reference external" href="https://osdn.net/projects/joypy/ticket/">Bug tracker</a></p></li>
<li><a class="reference external" href="https://osdn.net/projects/joypy/forums/">Forums</a></li> <li><p><a class="reference external" href="https://osdn.net/projects/joypy/forums/">Forums</a></p></li>
<li><a class="reference external" href="https://osdn.net/projects/joypy/lists/">Mailing list</a></li> <li><p><a class="reference external" href="https://osdn.net/projects/joypy/lists/">Mailing list</a></p></li>
</ul> </ul>
</div> </section>
<div class="section" id="information-on-the-joy-language"> <section id="information-on-the-joy-language">
<h2>Information on the Joy language<a class="headerlink" href="#information-on-the-joy-language" title="Permalink to this headline"></a></h2> <h2>Information on the Joy language<a class="headerlink" href="#information-on-the-joy-language" title="Permalink to this headline"></a></h2>
<p>See <a class="reference external" href="https://en.wikipedia.org/wiki/Joy_(programming_language)">the Wikipedia article</a> and <a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/index.html">Kevin Albrecht’s mirror of Manfred von Thun’s original website for the Joy Programming Language</a> for more information on the Joy language.</p> <p>See <a class="reference external" href="https://en.wikipedia.org/wiki/Joy_(programming_language)">the Wikipedia article</a> and <a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/index.html">Kevin Albrecht’s mirror of Manfred von Thun’s original website for the Joy Programming Language</a> for more information on the Joy language.</p>
<p>The best source (no pun intended) for learning about Joy is the <p>The best source (no pun intended) for learning about Joy is the
@ -84,8 +85,8 @@ original C interpreter, Joy language source code for various functions,
and a great deal of fascinating material mostly written by Von Thun on and a great deal of fascinating material mostly written by Von Thun on
Joy and its deeper facets as well as how to program in it and several Joy and its deeper facets as well as how to program in it and several
interesting aspects. It’s quite a treasure trove.</p> interesting aspects. It’s quite a treasure trove.</p>
</div> </section>
<div class="section" id="documentation-on-thun-dialect"> <section id="documentation-on-thun-dialect">
<h2>Documentation on Thun Dialect<a class="headerlink" href="#documentation-on-thun-dialect" title="Permalink to this headline"></a></h2> <h2>Documentation on Thun Dialect<a class="headerlink" href="#documentation-on-thun-dialect" title="Permalink to this headline"></a></h2>
<p>The following is specific information for this dialect of Joy.</p> <p>The following is specific information for this dialect of Joy.</p>
<div class="toctree-wrapper compound"> <div class="toctree-wrapper compound">
@ -155,34 +156,46 @@ interesting aspects. It’s quite a treasure trove.</p>
</li> </li>
</ul> </ul>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="indices-and-tables"> <section id="indices-and-tables">
<h1>Indices and tables<a class="headerlink" href="#indices-and-tables" title="Permalink to this headline"></a></h1> <h1>Indices and tables<a class="headerlink" href="#indices-and-tables" title="Permalink to this headline"></a></h1>
<ul class="simple"> <ul class="simple">
<li><a class="reference internal" href="genindex.html"><span class="std std-ref">Index</span></a></li> <li><p><a class="reference internal" href="genindex.html"><span class="std std-ref">Index</span></a></p></li>
<li><a class="reference internal" href="py-modindex.html"><span class="std std-ref">Module Index</span></a></li> <li><p><a class="reference internal" href="py-modindex.html"><span class="std std-ref">Module Index</span></a></p></li>
<li><a class="reference internal" href="search.html"><span class="std std-ref">Search Page</span></a></li> <li><p><a class="reference internal" href="search.html"><span class="std std-ref">Search Page</span></a></p></li>
</ul> </ul>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="#">Table Of Contents</a></h3> <h1 class="logo"><a href="#">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Thun 0.4.1 Documentation</a><ul>
<li><a class="reference internal" href="#quick-start">Quick Start</a></li>
<li><a class="reference internal" href="#project-hosted-on-osdn">Project Hosted on OSDN</a></li>
<li><a class="reference internal" href="#information-on-the-joy-language">Information on the Joy language</a></li>
<li><a class="reference internal" href="#documentation-on-thun-dialect">Documentation on Thun Dialect</a></li>
</ul>
</li>
<li><a class="reference internal" href="#indices-and-tables">Indices and tables</a></li> <h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -191,25 +204,24 @@ interesting aspects. It’s quite a treasure trove.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/index.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -220,7 +232,7 @@ interesting aspects. It’s quite a treasure trove.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

206
docs/sphinx_docs/_build/html/joy.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Joy Interpreter &#8212; Thun 0.4.1 documentation</title> <title>Joy Interpreter &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Stack or Quote or Sequence or List…" href="stack.html" /> <link rel="next" title="Stack or Quote or Sequence or List…" href="stack.html" />
@ -30,105 +29,131 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="joy-interpreter"> <section id="joy-interpreter">
<h1>Joy Interpreter<a class="headerlink" href="#joy-interpreter" title="Permalink to this headline"></a></h1> <h1>Joy Interpreter<a class="headerlink" href="#joy-interpreter" title="Permalink to this headline"></a></h1>
<div class="section" id="module-joy.joy"> <section id="module-joy.joy">
<span id="joy-joy"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.joy</span></code><a class="headerlink" href="#module-joy.joy" title="Permalink to this headline"></a></h2> <span id="joy-joy"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.joy</span></code><a class="headerlink" href="#module-joy.joy" title="Permalink to this headline"></a></h2>
<p>This module implements an interpreter for a dialect of Joy that <p>This module implements an interpreter for a dialect of Joy that
attempts to stay very close to the spirit of Joy but does not precisely attempts to stay very close to the spirit of Joy but does not precisely
match the behaviour of the original version(s) written in C.</p> match the behaviour of the original version(s) written in C.</p>
<dl class="function"> <dl class="py exception">
<dt id="joy.joy.joy"> <dt class="sig sig-object py" id="joy.joy.UnknownSymbolError">
<code class="descclassname">joy.joy.</code><code class="descname">joy</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em>, <em>viewer=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#joy"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.joy.joy" title="Permalink to this definition"></a></dt> <em class="property"><span class="pre">exception</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">joy.joy.</span></span><span class="sig-name descname"><span class="pre">UnknownSymbolError</span></span><a class="reference internal" href="_modules/joy/joy.html#UnknownSymbolError"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.joy.UnknownSymbolError" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="py function">
<dt class="sig sig-object py" id="joy.joy.interp">
<span class="sig-prename descclassname"><span class="pre">joy.joy.</span></span><span class="sig-name descname"><span class="pre">interp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">()</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dictionary</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#interp"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.joy.interp" title="Permalink to this definition"></a></dt>
<dd><p>Simple REPL with no extra output, suitable for use in scripts.</p>
</dd></dl>
<dl class="py function">
<dt class="sig sig-object py" id="joy.joy.joy">
<span class="sig-prename descclassname"><span class="pre">joy.joy.</span></span><span class="sig-name descname"><span class="pre">joy</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">expression</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dictionary</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">viewer</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#joy"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.joy.joy" title="Permalink to this definition"></a></dt>
<dd><p>Evaluate a Joy expression on a stack.</p> <dd><p>Evaluate a Joy expression on a stack.</p>
<p>This function iterates through a sequence of terms which are either <p>This function iterates through a sequence of terms which are either
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
disctionary and executed.</p> dictionary and executed.</p>
<p>The viewer is a function that is called with the stack and expression <blockquote>
<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>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">param stack stack</dt>
<col class="field-body" /> <dd class="field-odd"><p>The stack.</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <dt class="field-even">param stack expression</dt>
<li><strong>stack</strong> (<em>stack</em>) – The stack.</li> <dd class="field-even"><p>The expression to evaluate.</p>
<li><strong>expression</strong> (<em>stack</em>) – The expression to evaluate.</li> </dd>
<li><strong>dictionary</strong> (<em>dict</em>) – A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</li> <dt class="field-odd">param dict dictionary</dt>
<li><strong>viewer</strong> (<em>function</em>) – Optional viewer function.</li> <dd class="field-odd"><p>A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</p>
</ul> </dd>
</td> <dt class="field-even">param function viewer</dt>
</tr> <dd class="field-even"><p>Optional viewer function.</p>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">(stack, (), dictionary)</p> </dd>
</td> <dt class="field-odd">rtype</dt>
</tr> <dd class="field-odd"><p>(stack, (), dictionary)</p>
</tbody> </dd>
</table> </dl>
</div></blockquote>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.joy.repl"> <dt class="sig sig-object py" id="joy.joy.repl">
<code class="descclassname">joy.joy.</code><code class="descname">repl</code><span class="sig-paren">(</span><em>stack=()</em>, <em>dictionary=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#repl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.joy.repl" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.joy.</span></span><span class="sig-name descname"><span class="pre">repl</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">()</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dictionary</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#repl"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.joy.repl" title="Permalink to this definition"></a></dt>
<dd><p>Read-Evaluate-Print Loop</p> <dd><p>Read-Evaluate-Print Loop</p>
<p>Accept input and run it on the stack, loop.</p> <p>Accept input and run it on the stack, loop.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>stack</strong> (<em>stack</em>) – The stack.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <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><strong>stack</strong> (<em>stack</em>) – The stack.</li>
<li><strong>dictionary</strong> (<em>dict</em>) – A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Return type</dt>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">stack</p> <dd class="field-even"><p>stack</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.joy.run"> <dt class="sig sig-object py" id="joy.joy.run">
<code class="descclassname">joy.joy.</code><code class="descname">run</code><span class="sig-paren">(</span><em>text</em>, <em>stack</em>, <em>dictionary</em>, <em>viewer=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#run"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.joy.run" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.joy.</span></span><span class="sig-name descname"><span class="pre">run</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">text</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dictionary</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">viewer</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#run"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.joy.run" title="Permalink to this definition"></a></dt>
<dd><p>Return the stack resulting from running the Joy code text on the stack.</p> <dd><p>Return the stack resulting from running the Joy code text on the stack.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>text</strong> (<em>str</em>) – Joy code.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><p><strong>stack</strong> (<em>stack</em>) – The stack.</p></li>
<li><strong>text</strong> (<em>str</em>) – Joy code.</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><strong>stack</strong> (<em>stack</em>) – The stack.</li> <li><p><strong>viewer</strong> (<em>function</em>) – Optional viewer function.</p></li>
<li><strong>dictionary</strong> (<em>dict</em>) – A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</li>
<li><strong>viewer</strong> (<em>function</em>) – Optional viewer function.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Return type</dt>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">(stack, (), dictionary)</p> <dd class="field-even"><p>(stack, (), dictionary)</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Joy Interpreter</a><ul>
<li><a class="reference internal" href="#module-joy.joy"><code class="docutils literal notranslate"><span class="pre">joy.joy</span></code></a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Joy Interpreter</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#module-joy.joy"><code class="docutils literal notranslate"><span class="pre">joy.joy</span></code></a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -138,25 +163,24 @@ on every iteration, its return value is ignored.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/joy.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -167,7 +191,7 @@ on every iteration, its return value is ignored.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

696
docs/sphinx_docs/_build/html/lib.html
View File

File diff suppressed because it is too large Load Diff

692
docs/sphinx_docs/_build/html/library.html
View File

File diff suppressed because it is too large Load Diff

100
docs/sphinx_docs/_build/html/notebooks/Categorical.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Categorical Programming &#8212; Thun 0.4.1 documentation</title> <title>Categorical Programming &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="The Four Fundamental Operations of Definite Action" href="The_Four_Operations.html" /> <link rel="next" title="The Four Fundamental Operations of Definite Action" href="The_Four_Operations.html" />
@ -30,25 +29,69 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="categorical-programming"> <section id="categorical-programming">
<h1>Categorical Programming<a class="headerlink" href="#categorical-programming" title="Permalink to this headline"></a></h1> <h1>Categorical Programming<a class="headerlink" href="#categorical-programming" title="Permalink to this headline"></a></h1>
<p>DRAFT</p> <p>DRAFT</p>
<p><a class="reference external" href="https://en.wikipedia.org/wiki/Category_theory">Categorical</a></p> <p><a class="reference external" href="https://en.wikipedia.org/wiki/Category_theory">Categorical</a></p>
<p>In Manfred von Thun’s article <a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/j08cnt.html">Joy compared with other functional languages</a> he asks, “Could the language of categories be used for writing programs? Any lambda expression can be translated into a categorical expression, so the language of categories is expressively complete. But this does not make it a suitable language for writing programs. As it stands it is a very low-level language.”</p> <p>In Manfred von Thun’s article <a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/j08cnt.html">Joy compared with other functional languages</a> he asks, “Could the language of categories be used for writing programs? Any lambda expression can be translated into a categorical expression, so the language of categories is expressively complete. But this does not make it a suitable language for writing programs. As it stands it is a very low-level language.”</p>
<p>In <a class="reference external" href="http://conal.net/papers/compiling-to-categories/">Compiling to categories</a> Conal Elliott give a taste of what this might mean.</p> <p>In <a class="reference external" href="http://conal.net/papers/compiling-to-categories/">Compiling to categories</a> Conal Elliott give a taste of what this might mean.</p>
<blockquote> <blockquote>
<div>It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.</div></blockquote> <div><p>It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.</p>
</div></blockquote>
<p>What he’s doing is translating lambda forms into a kind of “point-free” style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.</p> <p>What he’s doing is translating lambda forms into a kind of “point-free” style that is very close to Joy code (although more verbose) and then showing how to instantiate that code over different categories to get several different kinds of program out of the same code.</p>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
@ -59,25 +102,24 @@
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Categorical.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -88,7 +130,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

716
docs/sphinx_docs/_build/html/notebooks/Derivatives_of_Regular_Expressions.html
View File

File diff suppressed because it is too large Load Diff

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

File diff suppressed because one or more lines are too long

246
docs/sphinx_docs/_build/html/notebooks/Generator_Programs.html
View File

File diff suppressed because one or more lines are too long

198
docs/sphinx_docs/_build/html/notebooks/Intro.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Thun: Joy in Python &#8212; Thun 0.4.1 documentation</title> <title>Thun: Joy in Python &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Joy Interpreter" href="../joy.html" /> <link rel="next" title="Joy Interpreter" href="../joy.html" />
@ -30,20 +29,22 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="thun-joy-in-python"> <section id="thun-joy-in-python">
<h1>Thun: Joy in Python<a class="headerlink" href="#thun-joy-in-python" title="Permalink to this headline"></a></h1> <h1>Thun: Joy in Python<a class="headerlink" href="#thun-joy-in-python" title="Permalink to this headline"></a></h1>
<p>This implementation is meant as a tool for exploring the programming <p>This implementation is meant as a tool for exploring the programming
model and method of Joy. Python seems like a great implementation model and method of Joy. Python seems like a great implementation
language for Joy for several reasons.</p> language for Joy for several reasons.</p>
<ul class="simple"> <ul class="simple">
<li>We can lean on the Python immutable types for our basic semantics and types: ints, floats, strings, and tuples, which enforces functional purity.</li> <li><p>We can lean on the Python immutable types for our basic semantics and types: ints, floats, strings, and tuples, which enforces functional purity.</p></li>
<li>We get garbage collection for free.</li> <li><p>We get garbage collection for free.</p></li>
<li>Compilation via Cython.</li> <li><p>Compilation via Cython.</p></li>
<li>Python is a “glue language” with loads of libraries which we can wrap in Joy functions.</li> <li><p>Python is a “glue language” with loads of libraries which we can wrap in Joy functions.</p></li>
</ul> </ul>
<div class="section" id="read-eval-print-loop-repl"> <section id="read-eval-print-loop-repl">
<h2><a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">Read-Eval-Print Loop (REPL)</a><a class="headerlink" href="#read-eval-print-loop-repl" title="Permalink to this headline"></a></h2> <h2><a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">Read-Eval-Print Loop (REPL)</a><a class="headerlink" href="#read-eval-print-loop-repl" title="Permalink to this headline"></a></h2>
<p>The main way to interact with the Joy interpreter is through a simple <p>The main way to interact with the Joy interpreter is through a simple
<a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a> <a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>
@ -86,8 +87,8 @@ joy?
joy? joy?
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="the-stack"> <section id="the-stack">
<h2>The Stack<a class="headerlink" href="#the-stack" title="Permalink to this headline"></a></h2> <h2>The Stack<a class="headerlink" href="#the-stack" title="Permalink to this headline"></a></h2>
<p>In Joy, in addition to the types Boolean, integer, float, and string, <p>In Joy, in addition to the types Boolean, integer, float, and string,
there is a <a class="reference internal" href="../stack.html"><span class="doc">single sequence type</span></a> represented by enclosing a sequence of there is a <a class="reference internal" href="../stack.html"><span class="doc">single sequence type</span></a> represented by enclosing a sequence of
@ -95,21 +96,21 @@ terms in brackets <code class="docutils literal notranslate"><span class="pre">[
both the stack and the expression. It is a <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons both the stack and the expression. It is a <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons
list</a> made from Python list</a> made from Python
tuples.</p> tuples.</p>
</div> </section>
<div class="section" id="purely-functional-datastructures"> <section id="purely-functional-datastructures">
<h2>Purely Functional Datastructures<a class="headerlink" href="#purely-functional-datastructures" title="Permalink to this headline"></a></h2> <h2>Purely Functional Datastructures<a class="headerlink" href="#purely-functional-datastructures" title="Permalink to this headline"></a></h2>
<p>Because Joy stacks are made out of Python tuples they are immutable, as are the other Python types we “borrow” for Joy, so all Joy datastructures are <a class="reference external" href="https://en.wikipedia.org/wiki/Purely_functional_data_structure">purely functional</a>.</p> <p>Because Joy stacks are made out of Python tuples they are immutable, as are the other Python types we “borrow” for Joy, so all Joy datastructures are <a class="reference external" href="https://en.wikipedia.org/wiki/Purely_functional_data_structure">purely functional</a>.</p>
</div> </section>
<div class="section" id="the-joy-function"> <section id="the-joy-function">
<h2>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function<a class="headerlink" href="#the-joy-function" title="Permalink to this headline"></a></h2> <h2>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function<a class="headerlink" href="#the-joy-function" title="Permalink to this headline"></a></h2>
<div class="section" id="an-interpreter"> <section id="an-interpreter">
<h3>An Interpreter<a class="headerlink" href="#an-interpreter" title="Permalink to this headline"></a></h3> <h3>An Interpreter<a class="headerlink" href="#an-interpreter" title="Permalink to this headline"></a></h3>
<p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> interpreter function is extrememly simple. It accepts a stack, an <p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> interpreter function is extrememly simple. It accepts a stack, an
expression, and a dictionary, and it iterates through the expression expression, and a dictionary, and it iterates through the expression
putting values onto the stack and delegating execution to functions which it putting values onto the stack and delegating execution to functions which it
looks up in the dictionary.</p> looks up in the dictionary.</p>
</div> </section>
<div class="section" id="continuation-passing-style"> <section id="continuation-passing-style">
<h3><a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">Continuation-Passing Style</a><a class="headerlink" href="#continuation-passing-style" title="Permalink to this headline"></a></h3> <h3><a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">Continuation-Passing Style</a><a class="headerlink" href="#continuation-passing-style" title="Permalink to this headline"></a></h3>
<p>One day I thought, What happens if you rewrite Joy to use <p>One day I thought, What happens if you rewrite Joy to use
<a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">CPS</a>? I <a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">CPS</a>? I
@ -117,8 +118,8 @@ made all the functions accept and return the expression as well as the
stack and found that all the combinators could be rewritten to work by stack and found that all the combinators could be rewritten to work by
modifying the expression rather than making recursive calls to the modifying the expression rather than making recursive calls to the
<code class="docutils literal notranslate"><span class="pre">joy()</span></code> function.</p> <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function.</p>
</div> </section>
<div class="section" id="view-function"> <section id="view-function">
<h3>View function<a class="headerlink" href="#view-function" title="Permalink to this headline"></a></h3> <h3>View function<a class="headerlink" href="#view-function" title="Permalink to this headline"></a></h3>
<p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function accepts an optional <code class="docutils literal notranslate"><span class="pre">viewer</span></code> argument that <p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function accepts an optional <code class="docutils literal notranslate"><span class="pre">viewer</span></code> argument that
is a function which it calls on is a function which it calls on
@ -127,70 +128,70 @@ evaluation. This can be used for tracing, breakpoints, retrying after
exceptions, or interrupting an evaluation and saving to disk or sending exceptions, or interrupting an evaluation and saving to disk or sending
over the network to resume later. The stack and expression together over the network to resume later. The stack and expression together
contain all the state of the computation at each step.</p> contain all the state of the computation at each step.</p>
</div> </section>
<div class="section" id="the-traceprinter"> <section id="the-traceprinter">
<h3>The <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code>.<a class="headerlink" href="#the-traceprinter" title="Permalink to this headline"></a></h3> <h3>The <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code>.<a class="headerlink" href="#the-traceprinter" title="Permalink to this headline"></a></h3>
<p>A <code class="docutils literal notranslate"><span class="pre">viewer</span></code> records each step of the evaluation of a Joy program. The <p>A <code class="docutils literal notranslate"><span class="pre">viewer</span></code> records each step of the evaluation of a Joy program. The
<code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code> has a facility for printing out a trace of the <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code> has a facility for printing out a trace of the
evaluation, one line per step. Each step is aligned to the current evaluation, one line per step. Each step is aligned to the current
interpreter position, signified by a period separating the stack on the interpreter position, signified by a period separating the stack on the
left from the pending expression (“continuation”) on the right.</p> left from the pending expression (“continuation”) on the right.</p>
</div> </section>
</div> </section>
<div class="section" id="parser"> <section id="parser">
<h2>Parser<a class="headerlink" href="#parser" title="Permalink to this headline"></a></h2> <h2>Parser<a class="headerlink" href="#parser" title="Permalink to this headline"></a></h2>
<p>The parser is extremely simple. The undocumented <code class="docutils literal notranslate"><span class="pre">re.Scanner</span></code> class <p>The parser is extremely simple. The undocumented <code class="docutils literal notranslate"><span class="pre">re.Scanner</span></code> class
does the tokenizing and then the parser builds the tuple does the tokenizing and then the parser builds the tuple
structure out of the tokens. There’s no Abstract Syntax Tree or anything structure out of the tokens. There’s no Abstract Syntax Tree or anything
like that.</p> like that.</p>
<div class="section" id="symbols"> <section id="symbols">
<h3>Symbols<a class="headerlink" href="#symbols" title="Permalink to this headline"></a></h3> <h3>Symbols<a class="headerlink" href="#symbols" title="Permalink to this headline"></a></h3>
<p>TODO: Symbols are just a string subclass; used by the parser to represent function names and by the interpreter to look up functions in the dictionary. N.B.: Symbols are not looked up at parse-time. You <em>could</em> define recursive functions, er, recusively, without <code class="docutils literal notranslate"><span class="pre">genrec</span></code> or other recursion combinators <code class="docutils literal notranslate"><span class="pre">foo</span> <span class="pre">==</span> <span class="pre">...</span> <span class="pre">foo</span> <span class="pre">...</span></code> but don’t do that.</p> <p>TODO: Symbols are just a string subclass; used by the parser to represent function names and by the interpreter to look up functions in the dictionary. N.B.: Symbols are not looked up at parse-time. You <em>could</em> define recursive functions, er, recusively, without <code class="docutils literal notranslate"><span class="pre">genrec</span></code> or other recursion combinators <code class="docutils literal notranslate"><span class="pre">foo</span> <span class="pre">==</span> <span class="pre">...</span> <span class="pre">foo</span> <span class="pre">...</span></code> but don’t do that.</p>
</div> </section>
<div class="section" id="token-regular-expressions"> <section id="token-regular-expressions">
<h3>Token Regular Expressions<a class="headerlink" href="#token-regular-expressions" title="Permalink to this headline"></a></h3> <h3>Token Regular Expressions<a class="headerlink" href="#token-regular-expressions" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">123</span> <span class="mf">1.2</span> <span class="s1">&#39;single quotes&#39;</span> <span class="s2">&quot;double quotes&quot;</span> <span class="n">function</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">123</span> <span class="mf">1.2</span> <span class="s1">&#39;single quotes&#39;</span> <span class="s2">&quot;double quotes&quot;</span> <span class="n">function</span>
</pre></div> </pre></div>
</div> </div>
<p>TBD (look in the :module: joy.parser module.)</p> <p>TBD (look in the :module: joy.parser module.)</p>
</div> </section>
<div class="section" id="examples"> <section id="examples">
<h3>Examples<a class="headerlink" href="#examples" title="Permalink to this headline"></a></h3> <h3>Examples<a class="headerlink" href="#examples" title="Permalink to this headline"></a></h3>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;1 2 3 4 5&#39;</span><span class="p">)</span> <span class="c1"># A simple sequence.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>joy.parser.text_to_expression(&#39;1 2 3 4 5&#39;) # A simple sequence.
</pre></div> </pre></div>
</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="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))))</span> <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="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))))</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[1 2 3] 4 5&#39;</span><span class="p">)</span> <span class="c1"># Three items, the first is a list with three items</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>joy.parser.text_to_expression(&#39;[1 2 3] 4 5&#39;) # Three items, the first is a list with three items
</pre></div> </pre></div>
</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="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))</span> <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="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;1 23 [&quot;four&quot; [-5.0] cons] 8888&#39;</span><span class="p">)</span> <span class="c1"># A mixed bag. cons is</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>joy.parser.text_to_expression(&#39;1 23 [&quot;four&quot; [-5.0] cons] 8888&#39;) # A mixed bag. cons is
<span class="c1"># a Symbol, no lookup at</span> # a Symbol, no lookup at
<span class="c1"># parse-time. Haiku docs.</span> # parse-time. Haiku docs.
</pre></div> </pre></div>
</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="p">(</span><span class="mi">23</span><span class="p">,</span> <span class="p">((</span><span class="s1">&#39;four&#39;</span><span class="p">,</span> <span class="p">((</span><span class="o">-</span><span class="mf">5.0</span><span class="p">,</span> <span class="p">()),</span> <span class="p">(</span><span class="n">cons</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">8888</span><span class="p">,</span> <span class="p">()))))</span> <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="p">(</span><span class="mi">23</span><span class="p">,</span> <span class="p">((</span><span class="s1">&#39;four&#39;</span><span class="p">,</span> <span class="p">((</span><span class="o">-</span><span class="mf">5.0</span><span class="p">,</span> <span class="p">()),</span> <span class="p">(</span><span class="n">cons</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">8888</span><span class="p">,</span> <span class="p">()))))</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[][][][][]&#39;</span><span class="p">)</span> <span class="c1"># Five empty lists.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>joy.parser.text_to_expression(&#39;[][][][][]&#39;) # Five empty lists.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">())))))</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">())))))</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[[[[[]]]]]&#39;</span><span class="p">)</span> <span class="c1"># Five nested lists.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>joy.parser.text_to_expression(&#39;[[[[[]]]]]&#39;) # Five nested lists.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((((((),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">())</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((((((),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">())</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="library"> <section id="library">
<h2>Library<a class="headerlink" href="#library" title="Permalink to this headline"></a></h2> <h2>Library<a class="headerlink" href="#library" title="Permalink to this headline"></a></h2>
<p>The Joy library of functions (aka commands, or “words” after Forth <p>The Joy library of functions (aka commands, or “words” after Forth
usage) encapsulates all the actual functionality (no pun intended) of usage) encapsulates all the actual functionality (no pun intended) of
@ -198,7 +199,7 @@ the Joy system. There are simple functions such as addition <code class="docutil
<code class="docutils literal notranslate"><span class="pre">+</span></code>, the library module supports aliases), and combinators which <code class="docutils literal notranslate"><span class="pre">+</span></code>, the library module supports aliases), and combinators which
provide control-flow and higher-order operations.</p> provide control-flow and higher-order operations.</p>
<p>Many of the functions are defined in Python, like <code class="docutils literal notranslate"><span class="pre">dip</span></code>:</p> <p>Many of the functions are defined in Python, like <code class="docutils literal notranslate"><span class="pre">dip</span></code>:</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">joy</span><span class="o">.</span><span class="n">library</span><span class="o">.</span><span class="n">dip</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print inspect.getsource(joy.library.dip)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
@ -211,11 +212,10 @@ provide control-flow and higher-order operations.</p>
When the interpreter executes a definition function that function just When the interpreter executes a definition function that function just
pushes its body expression onto the pending expression (the pushes its body expression onto the pending expression (the
continuation) and returns control to the interpreter.</p> continuation) and returns control to the interpreter.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">joy</span><span class="o">.</span><span class="n">library</span><span class="o">.</span><span class="n">definitions</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print joy.library.definitions
</pre></div> </pre></div>
</div> </div>
<pre class="literal-block"> <pre class="literal-block">second == rest first
second == rest first
third == rest rest first third == rest rest first
product == 1 swap [*] step product == 1 swap [*] step
swons == swap cons swons == swap cons
@ -248,8 +248,7 @@ anamorphism == [pop []] swap [dip swons] genrec
range == [0 &lt;=] [1 - dup] anamorphism range == [0 &lt;=] [1 - dup] anamorphism
while == swap [nullary] cons dup dipd concat loop while == swap [nullary] cons dup dipd concat loop
dudipd == dup dipd dudipd == dup dipd
primrec == [i] genrec primrec == [i] genrec</pre>
</pre>
<p>Currently, there’s no function to add new definitions to the dictionary <p>Currently, there’s no function to add new definitions to the dictionary
from “within” Joy code itself. Adding new definitions remains a from “within” Joy code itself. Adding new definitions remains a
meta-interpreter action. You have to do it yourself, in Python, and wash meta-interpreter action. You have to do it yourself, in Python, and wash
@ -260,7 +259,7 @@ stack and expression. There’s an implicit <em>standard dictionary</em> that
defines the actual semantics of the syntactic stack and expression defines the actual semantics of the syntactic stack and expression
datastructures (which only contain symbols, not the actual functions. datastructures (which only contain symbols, not the actual functions.
Pickle some and see for yourself.)</p> Pickle some and see for yourself.)</p>
<div class="section" id="there-should-be-only-one"> <section id="there-should-be-only-one">
<h3>“There should be only one.”<a class="headerlink" href="#there-should-be-only-one" title="Permalink to this headline"></a></h3> <h3>“There should be only one.”<a class="headerlink" href="#there-should-be-only-one" title="Permalink to this headline"></a></h3>
<p>Which brings me to talking about one of my hopes and dreams for this <p>Which brings me to talking about one of my hopes and dreams for this
notation: “There should be only one.” What I mean is that there should notation: “There should be only one.” What I mean is that there should
@ -277,8 +276,8 @@ frameworks, programming languages. It’s a waste of time, a <a class="reference
“thundering herd” “thundering herd”
attack</a> on attack</a> on
human mentality.</p> human mentality.</p>
</div> </section>
<div class="section" id="literary-code-library"> <section id="literary-code-library">
<h3>Literary Code Library<a class="headerlink" href="#literary-code-library" title="Permalink to this headline"></a></h3> <h3>Literary Code Library<a class="headerlink" href="#literary-code-library" title="Permalink to this headline"></a></h3>
<p>If you read over the other notebooks you’ll see that developing code in <p>If you read over the other notebooks you’ll see that developing code in
Joy is a lot like doing simple mathematics, and the descriptions of the Joy is a lot like doing simple mathematics, and the descriptions of the
@ -292,43 +291,47 @@ card is highly desirable. Less code has fewer errors. The structure of
Joy engenders a kind of thinking that seems to be very effective for Joy engenders a kind of thinking that seems to be very effective for
developing structured processes.</p> developing structured processes.</p>
<p>There seems to be an elegance and power to the notation.</p> <p>There seems to be an elegance and power to the notation.</p>
</div> </section>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Thun: Joy in Python</a><ul>
<li><a class="reference internal" href="#read-eval-print-loop-repl">Read-Eval-Print Loop (REPL)</a></li>
<li><a class="reference internal" href="#the-stack">The Stack</a></li>
<li><a class="reference internal" href="#purely-functional-datastructures">Purely Functional Datastructures</a></li>
<li><a class="reference internal" href="#the-joy-function">The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function</a><ul>
<li><a class="reference internal" href="#an-interpreter">An Interpreter</a></li>
<li><a class="reference internal" href="#continuation-passing-style">Continuation-Passing Style</a></li>
<li><a class="reference internal" href="#view-function">View function</a></li> <h3>Navigation</h3>
<li><a class="reference internal" href="#the-traceprinter">The <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code>.</a></li> <ul class="current">
</ul> <li class="toctree-l1 current"><a class="current reference internal" href="#">Thun: Joy in Python</a><ul>
</li> <li class="toctree-l2"><a class="reference internal" href="#read-eval-print-loop-repl">Read-Eval-Print Loop (REPL)</a></li>
<li><a class="reference internal" href="#parser">Parser</a><ul> <li class="toctree-l2"><a class="reference internal" href="#the-stack">The Stack</a></li>
<li><a class="reference internal" href="#symbols">Symbols</a></li> <li class="toctree-l2"><a class="reference internal" href="#purely-functional-datastructures">Purely Functional Datastructures</a></li>
<li><a class="reference internal" href="#token-regular-expressions">Token Regular Expressions</a></li> <li class="toctree-l2"><a class="reference internal" href="#the-joy-function">The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function</a></li>
<li><a class="reference internal" href="#examples">Examples</a></li> <li class="toctree-l2"><a class="reference internal" href="#parser">Parser</a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="#library">Library</a></li>
</li>
<li><a class="reference internal" href="#library">Library</a><ul>
<li><a class="reference internal" href="#there-should-be-only-one">“There should be only one.”</a></li>
<li><a class="reference internal" href="#literary-code-library">Literary Code Library</a></li>
</ul>
</li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -338,25 +341,24 @@ developing structured processes.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Intro.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -367,7 +369,7 @@ developing structured processes.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

178
docs/sphinx_docs/_build/html/notebooks/Newton-Raphson.html
View File

@ -1,19 +1,19 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Newton’s method &#8212; Thun 0.4.1 documentation</title> <title>Newton’s method &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script defer="defer" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Traversing Datastructures with Zippers" href="Zipper.html" /> <link rel="next" title="Traversing Datastructures with Zippers" href="Zipper.html" />
@ -30,18 +30,20 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="newton-s-method"> <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> <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 <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> 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 <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> Hughes</a></p>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import J, V, define
</pre></div> </pre></div>
</div> </div>
<div class="section" id="a-generator-for-approximations"> <section id="a-generator-for-approximations">
<h2>A Generator for Approximations<a class="headerlink" href="#a-generator-for-approximations" title="Permalink to this headline"></a></h2> <h2>A Generator for Approximations<a class="headerlink" href="#a-generator-for-approximations" title="Permalink to this headline"></a></h2>
<p>To make a generator that generates successive approximations let’s start <p>To make a generator that generates successive approximations let’s start
by assuming an initial approximation and then derive the function that by assuming an initial approximation and then derive the function that
@ -51,7 +53,7 @@ computes the next approximation:</p>
<span class="n">a</span><span class="s1">&#39;</span> <span class="n">a</span><span class="s1">&#39;</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="a-function-to-compute-the-next-approximation"> <section id="a-function-to-compute-the-next-approximation">
<h3>A Function to Compute the Next Approximation<a class="headerlink" href="#a-function-to-compute-the-next-approximation" title="Permalink to this headline"></a></h3> <h3>A Function to Compute the Next Approximation<a class="headerlink" href="#a-function-to-compute-the-next-approximation" title="Permalink to this headline"></a></h3>
<p>This is the equation for computing the next approximate value of the <p>This is the equation for computing the next approximate value of the
square root:</p> square root:</p>
@ -67,8 +69,8 @@ square root:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</span> <span class="o">==</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</span> <span class="o">==</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="make-it-into-a-generator"> <section id="make-it-into-a-generator">
<h3>Make it into a Generator<a class="headerlink" href="#make-it-into-a-generator" title="Permalink to this headline"></a></h3> <h3>Make it into a Generator<a class="headerlink" href="#make-it-into-a-generator" title="Permalink to this headline"></a></h3>
<p>Our generator would be created by:</p> <p>Our generator would be created by:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">dup</span> <span class="n">F</span><span class="p">]</span> <span class="n">make_generator</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">dup</span> <span class="n">F</span><span class="p">]</span> <span class="n">make_generator</span>
@ -90,10 +92,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> <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> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>define(&#39;gsra 1 swap [over / + 2 /] cons [dup] swoncat make_generator&#39;)
</pre></div> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>J(&#39;23 gsra&#39;)
</pre></div> </pre></div>
</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> <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,23 +103,24 @@ function we’re writing. If we let 1 be the initial approximation:</p>
</div> </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 <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> square the approximation to see how well it works…</p>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>J(&#39;23 gsra 6 [x popd] times first sqr&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">23.0000000001585</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">23.0000000001585</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="finding-consecutive-approximations-within-a-tolerance"> <section id="finding-consecutive-approximations-within-a-tolerance">
<h2>Finding Consecutive Approximations within a Tolerance<a class="headerlink" href="#finding-consecutive-approximations-within-a-tolerance" title="Permalink to this headline"></a></h2> <h2>Finding Consecutive Approximations within a Tolerance<a class="headerlink" href="#finding-consecutive-approximations-within-a-tolerance" title="Permalink to this headline"></a></h2>
<p>From <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why Functional Programming Matters” by John <p>From <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> Hughes</a>:</p>
<blockquote> <blockquote>
<div>The remainder of a square root finder is a function <em>within</em>, which <div><p>The remainder of a square root finder is a function <em>within</em>, which
takes a tolerance and a list of approximations and looks down the takes a tolerance and a list of approximations and looks down the
list for two successive approximations that differ by no more than list for two successive approximations that differ by no more than
the given tolerance.</div></blockquote> the given tolerance.</p>
</div></blockquote>
<p>(And note that by “list” he means a lazily-evaluated list.)</p> <p>(And note that by “list” he means a lazily-evaluated list.)</p>
<p>Using the <em>output</em> <code class="docutils literal notranslate"><span class="pre">[a</span> <span class="pre">G]</span></code> of the above generator for square root <p>Using the <em>output</em> <code class="docutils literal notranslate"><span class="pre">[a</span> <span class="pre">G]</span></code> of the above generator for square root
approximations, and further assuming that the first term a has been approximations, and further assuming that the first term a has been
@ -132,7 +135,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> <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> </pre></div>
</div> </div>
<div class="section" id="predicate"> <section id="predicate">
<h3>Predicate<a class="headerlink" href="#predicate" title="Permalink to this headline"></a></h3> <h3>Predicate<a class="headerlink" href="#predicate" title="Permalink to this headline"></a></h3>
<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="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o">&lt;=</span> <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="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o">&lt;=</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">first</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o">&lt;=</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">first</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o">&lt;=</span>
@ -142,11 +145,11 @@ 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> <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> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>define(&#39;_within_P [first - abs] dip &lt;=&#39;)
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="base-case"> <section id="base-case">
<h3>Base-Case<a class="headerlink" href="#base-case" title="Permalink to this headline"></a></h3> <h3>Base-Case<a class="headerlink" href="#base-case" title="Permalink to this headline"></a></h3>
<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">roll</span><span class="o">&lt;</span> <span class="n">popop</span> <span class="n">first</span> <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">roll</span><span class="o">&lt;</span> <span class="n">popop</span> <span class="n">first</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">a</span> <span class="n">popop</span> <span class="n">first</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">a</span> <span class="n">popop</span> <span class="n">first</span>
@ -154,19 +157,19 @@ generated already and epsilon ε is handy on the stack…</p>
<span class="n">b</span> <span class="n">b</span>
</pre></div> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>define(&#39;_within_B roll&lt; popop first&#39;)
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="recur"> <section id="recur">
<h3>Recur<a class="headerlink" href="#recur" title="Permalink to this headline"></a></h3> <h3>Recur<a class="headerlink" href="#recur" title="Permalink to this headline"></a></h3>
<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> <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>
</pre></div> </pre></div>
</div> </div>
<ol class="arabic simple"> <ol class="arabic simple">
<li>Discard a.</li> <li><p>Discard a.</p></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><p>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>.</p></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> <li><p>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.)</p></li>
</ol> </ol>
<p>Pretty straightforward:</p> <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> <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,11 +182,11 @@ 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> <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> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>define(&#39;_within_R [popd x] dip&#39;)
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="setting-up"> <section id="setting-up">
<h3>Setting up<a class="headerlink" href="#setting-up" title="Permalink to this headline"></a></h3> <h3>Setting up<a class="headerlink" href="#setting-up" title="Permalink to this headline"></a></h3>
<p>The recursive function we have defined so far needs a slight preamble: <p>The recursive function we have defined so far needs a slight preamble:
<code class="docutils literal notranslate"><span class="pre">x</span></code> to prime the generator and the epsilon value to use:</p> <code class="docutils literal notranslate"><span class="pre">x</span></code> to prime the generator and the epsilon value to use:</p>
@ -191,66 +194,88 @@ 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> <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> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>define(&#39;within x 0.000000001 [_within_P] [_within_B] [_within_R] tailrec&#39;)
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;sqrt gsra within&#39;</span><span class="p">)</span> define(&#39;sqrt gsra within&#39;)
</pre></div> </pre></div>
</div> </div>
<p>Try it out…</p> <p>Try it out…</p>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>J(&#39;36 sqrt&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">6.0</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">6.0</span>
</pre></div> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>J(&#39;23 sqrt&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span>
</pre></div> </pre></div>
</div> </div>
<p>Check it.</p> <p>Check it.</p>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>4.795831523312719**2
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">22.999999999999996</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">22.999999999999996</span>
</pre></div> </pre></div>
</div> </div>
<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> <div class="highlight-ipython3 notranslate"><div class="highlight"><pre><span></span>from math import sqrt
<span class="n">sqrt</span><span class="p">(</span><span class="mi">23</span><span class="p">)</span> sqrt(23)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4.795831523312719</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Newton’s method</a><ul>
<li><a class="reference internal" href="#a-generator-for-approximations">A Generator for Approximations</a><ul>
<li><a class="reference internal" href="#a-function-to-compute-the-next-approximation">A Function to Compute the Next Approximation</a></li>
<li><a class="reference internal" href="#make-it-into-a-generator">Make it into a Generator</a></li>
</ul>
</li>
<li><a class="reference internal" href="#finding-consecutive-approximations-within-a-tolerance">Finding Consecutive Approximations within a Tolerance</a><ul>
<li><a class="reference internal" href="#predicate">Predicate</a></li> <h3>Navigation</h3>
<li><a class="reference internal" href="#base-case">Base-Case</a></li> <ul class="current">
<li><a class="reference internal" href="#recur">Recur</a></li> <li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li><a class="reference internal" href="#setting-up">Setting up</a></li> <li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
</ul> <li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
</li> <li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -262,25 +287,24 @@ generated already and epsilon ε is handy on the stack…</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Newton-Raphson.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -291,7 +315,7 @@ generated already and epsilon ε is handy on the stack…</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

113
docs/sphinx_docs/_build/html/notebooks/NoUpdates.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>No Updates &#8212; Thun 0.4.1 documentation</title> <title>No Updates &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Categorical Programming" href="Categorical.html" /> <link rel="next" title="Categorical Programming" href="Categorical.html" />
@ -30,39 +29,82 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="no-updates"> <section id="no-updates">
<h1>No Updates<a class="headerlink" href="#no-updates" title="Permalink to this headline"></a></h1> <h1>No Updates<a class="headerlink" href="#no-updates" title="Permalink to this headline"></a></h1>
<p>DRAFT</p> <p>DRAFT</p>
<ol class="arabic simple"> <ol class="arabic simple">
<li>Joy doesn’t need to change.</li> <li><p>Joy doesn’t need to change.</p></li>
</ol> </ol>
<blockquote> <blockquote>
<div><ol class="upperalpha simple"> <div><ol class="upperalpha simple">
<li>The interpreter doesn’t need to change, <code class="docutils literal notranslate"><span class="pre">viewer</span></code> function can customize mainloop. Or use a sub-interpreter (Joy in Joy.) The base interpreter remains static.</li> <li><p>The interpreter doesn’t need to change, <code class="docutils literal notranslate"><span class="pre">viewer</span></code> function can customize mainloop. Or use a sub-interpreter (Joy in Joy.) The base interpreter remains static.</p></li>
<li>Once a function has been named and defined <em>never change that name</em>. It’s just not allowed. If you need to change a function <code class="docutils literal notranslate"><span class="pre">foo</span></code> you have to call it <code class="docutils literal notranslate"><span class="pre">foo_II</span></code> or something. Once a function (name mapped to behavior) is released to the public <em>that’s it</em>, it’s done.</li> <li><p>Once a function has been named and defined <em>never change that name</em>. It’s just not allowed. If you need to change a function <code class="docutils literal notranslate"><span class="pre">foo</span></code> you have to call it <code class="docutils literal notranslate"><span class="pre">foo_II</span></code> or something. Once a function (name mapped to behavior) is released to the public <em>that’s it</em>, it’s done.</p></li>
<li>The language evolves by adding new definitions and refactoring, always choosing new names for new functions.</li> <li><p>The language evolves by adding new definitions and refactoring, always choosing new names for new functions.</p></li>
</ol> </ol>
</div></blockquote> </div></blockquote>
<ol class="arabic simple" start="2"> <ol class="arabic simple" start="2">
<li>Following <a class="reference external" href="https://semver.org">Semantic Versioning</a> there will never be a version 2.0.</li> <li><p>Following <a class="reference external" href="https://semver.org">Semantic Versioning</a> there will never be a version 2.0.</p></li>
</ol> </ol>
<blockquote> <blockquote>
<div><ol class="upperalpha simple"> <div><ol class="upperalpha simple">
<li><a class="reference external" href="https://semver.org/#spec-item-8">Major version must be incremented if any backwards incompatible changes are introduced to the public API.</a></li> <li><p><a class="reference external" href="https://semver.org/#spec-item-8">Major version must be incremented if any backwards incompatible changes are introduced to the public API.</a></p></li>
<li>We never implement any backwards incompatible changes, so…</li> <li><p>We never implement any backwards incompatible changes, so…</p></li>
<li>We could see e.g. Thun version 1.273.3!</li> <li><p>We could see e.g. Thun version 1.273.3!</p></li>
</ol> </ol>
</div></blockquote> </div></blockquote>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
@ -73,25 +115,24 @@
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/NoUpdates.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -102,7 +143,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

556
docs/sphinx_docs/_build/html/notebooks/Ordered_Binary_Trees.html
View File

File diff suppressed because it is too large Load Diff

140
docs/sphinx_docs/_build/html/notebooks/Quadratic.html
View File

@ -1,19 +1,19 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Quadratic formula &#8212; Thun 0.4.1 documentation</title> <title>Quadratic formula &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script defer="defer" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Replacing Functions in the Dictionary" href="Replacing.html" /> <link rel="next" title="Replacing Functions in the Dictionary" href="Replacing.html" />
@ -30,12 +30,14 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<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="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import J, V, define
</pre></div> </pre></div>
</div> </div>
<div class="section" id="quadratic-formula"> <section id="quadratic-formula">
<h1><a class="reference external" href="https://en.wikipedia.org/wiki/Quadratic_formula">Quadratic formula</a><a class="headerlink" href="#quadratic-formula" title="Permalink to this headline"></a></h1> <h1><a class="reference external" href="https://en.wikipedia.org/wiki/Quadratic_formula">Quadratic formula</a><a class="headerlink" href="#quadratic-formula" title="Permalink to this headline"></a></h1>
<p>Cf. <p>Cf.
<a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/jp-quadratic.html">jp-quadratic.html</a></p> <a class="reference external" href="http://www.kevinalbrecht.com/code/joy-mirror/jp-quadratic.html">jp-quadratic.html</a></p>
@ -45,47 +47,47 @@
</pre></div> </pre></div>
</div> </div>
<p><span class="math notranslate nohighlight">\(\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}\)</span></p> <p><span class="math notranslate nohighlight">\(\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}\)</span></p>
<div class="section" id="write-a-straightforward-program-with-variable-names"> <section id="write-a-straightforward-program-with-variable-names">
<h2>Write a straightforward program with variable names.<a class="headerlink" href="#write-a-straightforward-program-with-variable-names" title="Permalink to this headline"></a></h2> <h2>Write a straightforward program with variable names.<a class="headerlink" href="#write-a-straightforward-program-with-variable-names" title="Permalink to this headline"></a></h2>
<p>This math translates to Joy code in a straightforward manner. We are <p>This math translates to Joy code in a straightforward manner. We are
going to use named variables to keep track of the arguments, then write going to use named variables to keep track of the arguments, then write
a definition without them.</p> a definition without them.</p>
<div class="section" id="b"> <section id="b">
<h3><code class="docutils literal notranslate"><span class="pre">-b</span></code><a class="headerlink" href="#b" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">-b</span></code><a class="headerlink" href="#b" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">neg</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">neg</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="sqrt-b-2-4-a-c"> <section id="sqrt-b-2-4-a-c">
<h3><code class="docutils literal notranslate"><span class="pre">sqrt(b^2</span> <span class="pre">-</span> <span class="pre">4</span> <span class="pre">*</span> <span class="pre">a</span> <span class="pre">*</span> <span class="pre">c)</span></code><a class="headerlink" href="#sqrt-b-2-4-a-c" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">sqrt(b^2</span> <span class="pre">-</span> <span class="pre">4</span> <span class="pre">*</span> <span class="pre">a</span> <span class="pre">*</span> <span class="pre">c)</span></code><a class="headerlink" href="#sqrt-b-2-4-a-c" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">sqr</span> <span class="mi">4</span> <span class="n">a</span> <span class="n">c</span> <span class="o">*</span> <span class="o">*</span> <span class="o">-</span> <span class="n">sqrt</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">sqr</span> <span class="mi">4</span> <span class="n">a</span> <span class="n">c</span> <span class="o">*</span> <span class="o">*</span> <span class="o">-</span> <span class="n">sqrt</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="a"> <section id="a">
<h3><code class="docutils literal notranslate"><span class="pre">/2a</span></code><a class="headerlink" href="#a" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">/2a</span></code><a class="headerlink" href="#a" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="mi">2</span> <span class="o">*</span> <span class="o">/</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="mi">2</span> <span class="o">*</span> <span class="o">/</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="id1"> <section id="id1">
<h3><code class="docutils literal notranslate"><span class="pre">±</span></code><a class="headerlink" href="#id1" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">±</span></code><a class="headerlink" href="#id1" title="Permalink to this headline"></a></h3>
<p>There is a function <code class="docutils literal notranslate"><span class="pre">pm</span></code> that accepts two values on the stack and <p>There is a function <code class="docutils literal notranslate"><span class="pre">pm</span></code> that accepts two values on the stack and
replaces them with their sum and difference.</p> replaces them with their sum and difference.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pm</span> <span class="o">==</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="p">[</span><span class="o">-</span><span class="p">]</span> <span class="n">cleave</span> <span class="n">popdd</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pm</span> <span class="o">==</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="p">[</span><span class="o">-</span><span class="p">]</span> <span class="n">cleave</span> <span class="n">popdd</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="putting-them-together"> <section id="putting-them-together">
<h3>Putting Them Together<a class="headerlink" href="#putting-them-together" title="Permalink to this headline"></a></h3> <h3>Putting Them Together<a class="headerlink" href="#putting-them-together" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">neg</span> <span class="n">b</span> <span class="n">sqr</span> <span class="mi">4</span> <span class="n">a</span> <span class="n">c</span> <span class="o">*</span> <span class="o">*</span> <span class="o">-</span> <span class="n">sqrt</span> <span class="n">pm</span> <span class="n">a</span> <span class="mi">2</span> <span class="o">*</span> <span class="p">[</span><span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="n">app2</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">b</span> <span class="n">neg</span> <span class="n">b</span> <span class="n">sqr</span> <span class="mi">4</span> <span class="n">a</span> <span class="n">c</span> <span class="o">*</span> <span class="o">*</span> <span class="o">-</span> <span class="n">sqrt</span> <span class="n">pm</span> <span class="n">a</span> <span class="mi">2</span> <span class="o">*</span> <span class="p">[</span><span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="n">app2</span>
</pre></div> </pre></div>
</div> </div>
<p>We use <code class="docutils literal notranslate"><span class="pre">app2</span></code> to compute both roots by using a quoted program <p>We use <code class="docutils literal notranslate"><span class="pre">app2</span></code> to compute both roots by using a quoted program
<code class="docutils literal notranslate"><span class="pre">[2a</span> <span class="pre">/]</span></code> built with <code class="docutils literal notranslate"><span class="pre">cons</span></code>.</p> <code class="docutils literal notranslate"><span class="pre">[2a</span> <span class="pre">/]</span></code> built with <code class="docutils literal notranslate"><span class="pre">cons</span></code>.</p>
</div> </section>
</div> </section>
<div class="section" id="derive-a-definition"> <section id="derive-a-definition">
<h2>Derive a definition.<a class="headerlink" href="#derive-a-definition" title="Permalink to this headline"></a></h2> <h2>Derive a definition.<a class="headerlink" href="#derive-a-definition" title="Permalink to this headline"></a></h2>
<p>Working backwards we use <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">dipd</span></code> to extract the code from <p>Working backwards we use <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">dipd</span></code> to extract the code from
the variables:</p> the variables:</p>
@ -98,11 +100,11 @@ the variables:</p>
</div> </div>
<p>The three arguments are to the left, so we can “chop off” everything to <p>The three arguments are to the left, so we can “chop off” everything to
the right and say it’s the definition of the <code class="docutils literal notranslate"><span class="pre">quadratic</span></code> function:</p> the right and say it’s the definition of the <code class="docutils literal notranslate"><span class="pre">quadratic</span></code> function:</p>
<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;quadratic == over [[[neg] dupdip sqr 4] dipd * * - sqrt pm] dip 2 * [/] cons app2&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;quadratic == over [[[neg] dupdip sqr 4] dipd * * - sqrt pm] dip 2 * [/] cons app2&#39;)
</pre></div> </pre></div>
</div> </div>
<p>Let’s try it out:</p> <p>Let’s 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;3 1 1 quadratic&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;3 1 1 quadratic&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">-</span><span class="mf">0.3819660112501051</span> <span class="o">-</span><span class="mf">2.618033988749895</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">-</span><span class="mf">0.3819660112501051</span> <span class="o">-</span><span class="mf">2.618033988749895</span>
@ -112,7 +114,7 @@ the right and say it’s the definition of the <code class="docutils literal not
lines are the <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">dipd</span></code> combinators building the main program lines are the <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">dipd</span></code> combinators building the main program
by incorporating the values on the stack. Then that program runs and you by incorporating the values on the stack. Then that program runs and you
get the results. This is pretty typical of Joy code.</p> get the results. This is pretty typical of Joy code.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;-5 1 4 quadratic&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;-5 1 4 quadratic&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="o">-</span><span class="mi">5</span> <span class="mi">1</span> <span class="mi">4</span> <span class="n">quadratic</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="o">-</span><span class="mi">5</span> <span class="mi">1</span> <span class="mi">4</span> <span class="n">quadratic</span>
@ -162,30 +164,55 @@ get the results. This is pretty typical of Joy code.</p>
<span class="mf">4.0</span> <span class="mf">1.0</span> <span class="o">.</span> <span class="mf">4.0</span> <span class="mf">1.0</span> <span class="o">.</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Quadratic formula</a><ul>
<li><a class="reference internal" href="#write-a-straightforward-program-with-variable-names">Write a straightforward program with variable names.</a><ul>
<li><a class="reference internal" href="#b"><code class="docutils literal notranslate"><span class="pre">-b</span></code></a></li>
<li><a class="reference internal" href="#sqrt-b-2-4-a-c"><code class="docutils literal notranslate"><span class="pre">sqrt(b^2</span> <span class="pre">-</span> <span class="pre">4</span> <span class="pre">*</span> <span class="pre">a</span> <span class="pre">*</span> <span class="pre">c)</span></code></a></li>
<li><a class="reference internal" href="#a"><code class="docutils literal notranslate"><span class="pre">/2a</span></code></a></li>
<li><a class="reference internal" href="#id1"><code class="docutils literal notranslate"><span class="pre">±</span></code></a></li>
<li><a class="reference internal" href="#putting-them-together">Putting Them Together</a></li>
</ul> <h3>Navigation</h3>
</li> <ul class="current">
<li><a class="reference internal" href="#derive-a-definition">Derive a definition.</a></li> <li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -197,25 +224,24 @@ get the results. This is pretty typical of Joy code.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Quadratic.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -226,7 +252,7 @@ get the results. This is pretty typical of Joy code.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

330
docs/sphinx_docs/_build/html/notebooks/Recursion_Combinators.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Recursion Combinators &#8212; Thun 0.4.1 documentation</title> <title>Recursion Combinators &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Treating Trees I: Ordered Binary Trees" href="Ordered_Binary_Trees.html" /> <link rel="next" title="Treating Trees I: Ordered Binary Trees" href="Ordered_Binary_Trees.html" />
@ -30,12 +29,14 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">D</span><span class="p">,</span> <span class="n">DefinitionWrapper</span><span class="p">,</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="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import D, DefinitionWrapper, J, V, define
</pre></div> </pre></div>
</div> </div>
<div class="section" id="recursion-combinators"> <section id="recursion-combinators">
<h1>Recursion Combinators<a class="headerlink" href="#recursion-combinators" title="Permalink to this headline"></a></h1> <h1>Recursion Combinators<a class="headerlink" href="#recursion-combinators" title="Permalink to this headline"></a></h1>
<p>This article describes the <code class="docutils literal notranslate"><span class="pre">genrec</span></code> combinator, how to use it, and <p>This article describes the <code class="docutils literal notranslate"><span class="pre">genrec</span></code> combinator, how to use it, and
several generic specializations.</p> several generic specializations.</p>
@ -46,7 +47,7 @@ several generic specializations.</p>
</div> </div>
<p>From “Recursion Theory and Joy” (j05cmp.html) by Manfred von Thun:</p> <p>From “Recursion Theory and Joy” (j05cmp.html) by Manfred von Thun:</p>
<blockquote> <blockquote>
<div>“The genrec combinator takes four program parameters in addition to <div><p>“The genrec combinator takes four program parameters in addition to
whatever data parameters it needs. Fourth from the top is an if-part, whatever data parameters it needs. Fourth from the top is an if-part,
followed by a then-part. If the if-part yields true, then the followed by a then-part. If the if-part yields true, then the
then-part is executed and the combinator terminates. The other two then-part is executed and the combinator terminates. The other two
@ -55,8 +56,9 @@ false, the rec1-part is executed. Following that the four program
parameters and the combinator are again pushed onto the stack bundled parameters and the combinator are again pushed onto the stack bundled
up in a quoted form. Then the rec2-part is executed, where it will up in a quoted form. Then the rec2-part is executed, where it will
find the bundled form. Typically it will then execute the bundled find the bundled form. Typically it will then execute the bundled
form, either with i or with app2, or some other combinator.”</div></blockquote> form, either with i or with app2, or some other combinator.”</p>
<div class="section" id="designing-recursive-functions"> </div></blockquote>
<section id="designing-recursive-functions">
<h2>Designing Recursive Functions<a class="headerlink" href="#designing-recursive-functions" title="Permalink to this headline"></a></h2> <h2>Designing Recursive Functions<a class="headerlink" href="#designing-recursive-functions" title="Permalink to this headline"></a></h2>
<p>The way to design one of these is to fix your base case and test and <p>The way to design one of these is to fix your base case and test and
then treat <code class="docutils literal notranslate"><span class="pre">R1</span></code> and <code class="docutils literal notranslate"><span class="pre">R2</span></code> as an else-part “sandwiching” a quotation then treat <code class="docutils literal notranslate"><span class="pre">R1</span></code> and <code class="docutils literal notranslate"><span class="pre">R2</span></code> as an else-part “sandwiching” a quotation
@ -73,8 +75,8 @@ from:</p>
</div> </div>
<p>Set the stack arguments in front and figure out what <code class="docutils literal notranslate"><span class="pre">R1</span></code> and <code class="docutils literal notranslate"><span class="pre">R2</span></code> <p>Set the stack arguments in front and figure out what <code class="docutils literal notranslate"><span class="pre">R1</span></code> and <code class="docutils literal notranslate"><span class="pre">R2</span></code>
have to do to apply the quoted <code class="docutils literal notranslate"><span class="pre">[F]</span></code> in the proper way.</p> have to do to apply the quoted <code class="docutils literal notranslate"><span class="pre">[F]</span></code> in the proper way.</p>
</div> </section>
<div class="section" id="primitive-recursive-functions"> <section id="primitive-recursive-functions">
<h2>Primitive Recursive Functions<a class="headerlink" href="#primitive-recursive-functions" title="Permalink to this headline"></a></h2> <h2>Primitive Recursive Functions<a class="headerlink" href="#primitive-recursive-functions" title="Permalink to this headline"></a></h2>
<p>Primitive recursive functions are those where <code class="docutils literal notranslate"><span class="pre">R2</span> <span class="pre">==</span> <span class="pre">i</span></code>.</p> <p>Primitive recursive functions are those where <code class="docutils literal notranslate"><span class="pre">R2</span> <span class="pre">==</span> <span class="pre">i</span></code>.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">P</span> <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span><span class="p">]</span> <span class="n">primrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">P</span> <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span><span class="p">]</span> <span class="n">primrec</span>
@ -82,35 +84,35 @@ have to do to apply the quoted <code class="docutils literal notranslate"><span
<span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="n">P</span><span class="p">]</span> <span class="n">ifte</span> <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="n">P</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="hylomorphism"> <section id="hylomorphism">
<h2><a class="reference external" href="https://en.wikipedia.org/wiki/Hylomorphism_%28computer_science%29">Hylomorphism</a><a class="headerlink" href="#hylomorphism" title="Permalink to this headline"></a></h2> <h2><a class="reference external" href="https://en.wikipedia.org/wiki/Hylomorphism_%28computer_science%29">Hylomorphism</a><a class="headerlink" href="#hylomorphism" title="Permalink to this headline"></a></h2>
<p>A <p>A
<a class="reference external" href="https://en.wikipedia.org/wiki/Hylomorphism_%28computer_science%29">hylomorphism</a> <a class="reference external" href="https://en.wikipedia.org/wiki/Hylomorphism_%28computer_science%29">hylomorphism</a>
is a recursive function <code class="docutils literal notranslate"><span class="pre">H</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">C</span></code> that converts a value of type is a recursive function <code class="docutils literal notranslate"><span class="pre">H</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">C</span></code> that converts a value of type
<code class="docutils literal notranslate"><span class="pre">A</span></code> into a value of type <code class="docutils literal notranslate"><span class="pre">C</span></code> by means of:</p> <code class="docutils literal notranslate"><span class="pre">A</span></code> into a value of type <code class="docutils literal notranslate"><span class="pre">C</span></code> by means of:</p>
<ul class="simple"> <ul class="simple">
<li>A generator <code class="docutils literal notranslate"><span class="pre">G</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">(B,</span> <span class="pre">A)</span></code></li> <li><p>A generator <code class="docutils literal notranslate"><span class="pre">G</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">(B,</span> <span class="pre">A)</span></code></p></li>
<li>A combiner <code class="docutils literal notranslate"><span class="pre">F</span> <span class="pre">::</span> <span class="pre">(B,</span> <span class="pre">C)</span> <span class="pre">-&gt;</span> <span class="pre">C</span></code></li> <li><p>A combiner <code class="docutils literal notranslate"><span class="pre">F</span> <span class="pre">::</span> <span class="pre">(B,</span> <span class="pre">C)</span> <span class="pre">-&gt;</span> <span class="pre">C</span></code></p></li>
<li>A predicate <code class="docutils literal notranslate"><span class="pre">P</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">Bool</span></code> to detect the base case</li> <li><p>A predicate <code class="docutils literal notranslate"><span class="pre">P</span> <span class="pre">::</span> <span class="pre">A</span> <span class="pre">-&gt;</span> <span class="pre">Bool</span></code> to detect the base case</p></li>
<li>A base case value <code class="docutils literal notranslate"><span class="pre">c</span> <span class="pre">::</span> <span class="pre">C</span></code></li> <li><p>A base case value <code class="docutils literal notranslate"><span class="pre">c</span> <span class="pre">::</span> <span class="pre">C</span></code></p></li>
<li>Recursive calls (zero or more); it has a “call stack in the form of a <li><p>Recursive calls (zero or more); it has a “call stack in the form of a
cons list”.</li> cons list”.</p></li>
</ul> </ul>
<p>It may be helpful to see this function implemented in imperative Python <p>It may be helpful to see this function implemented in imperative Python
code.</p> code.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">hylomorphism</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">F</span><span class="p">,</span> <span class="n">P</span><span class="p">,</span> <span class="n">G</span><span class="p">):</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def hylomorphism(c, F, P, G):
<span class="sd">&#39;&#39;&#39;Return a hylomorphism function H.&#39;&#39;&#39;</span> &#39;&#39;&#39;Return a hylomorphism function H.&#39;&#39;&#39;
<span class="k">def</span> <span class="nf">H</span><span class="p">(</span><span class="n">a</span><span class="p">):</span> def H(a):
<span class="k">if</span> <span class="n">P</span><span class="p">(</span><span class="n">a</span><span class="p">):</span> if P(a):
<span class="n">result</span> <span class="o">=</span> <span class="n">c</span> result = c
<span class="k">else</span><span class="p">:</span> else:
<span class="n">b</span><span class="p">,</span> <span class="n">aa</span> <span class="o">=</span> <span class="n">G</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> b, aa = G(a)
<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">H</span><span class="p">(</span><span class="n">aa</span><span class="p">))</span> <span class="c1"># b is stored in the stack frame during recursive call to H().</span> result = F(b, H(aa)) # b is stored in the stack frame during recursive call to H().
<span class="k">return</span> <span class="n">result</span> return result
<span class="k">return</span> <span class="n">H</span> return H
</pre></div> </pre></div>
</div> </div>
<p>Cf. <a class="reference external" href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.41.125">“Bananas, Lenses, &amp; Barbed <p>Cf. <a class="reference external" href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.41.125">“Bananas, Lenses, &amp; Barbed
@ -118,8 +120,8 @@ Wire”</a></p>
<p>Note that during evaluation of <code class="docutils literal notranslate"><span class="pre">H()</span></code> the intermediate <code class="docutils literal notranslate"><span class="pre">b</span></code> values are <p>Note that during evaluation of <code class="docutils literal notranslate"><span class="pre">H()</span></code> the intermediate <code class="docutils literal notranslate"><span class="pre">b</span></code> values are
stored in the Python call stack. This is what is meant by “call stack in stored in the Python call stack. This is what is meant by “call stack in
the form of a cons list”.</p> the form of a cons list”.</p>
</div> </section>
<div class="section" id="hylomorphism-in-joy"> <section id="hylomorphism-in-joy">
<h2>Hylomorphism in Joy<a class="headerlink" href="#hylomorphism-in-joy" title="Permalink to this headline"></a></h2> <h2>Hylomorphism in Joy<a class="headerlink" href="#hylomorphism-in-joy" title="Permalink to this headline"></a></h2>
<p>We can define a combinator <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> that will make a <p>We can define a combinator <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> that will make a
hylomorphism combinator <code class="docutils literal notranslate"><span class="pre">H</span></code> from constituent parts.</p> hylomorphism combinator <code class="docutils literal notranslate"><span class="pre">H</span></code> from constituent parts.</p>
@ -155,8 +157,8 @@ it is a simple specialization of the general recursion combinator.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">c</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">hylomorphism</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">c</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">hylomorphism</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="derivation-of-hylomorphism-combinator"> <section id="derivation-of-hylomorphism-combinator">
<h2>Derivation of <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> combinator<a class="headerlink" href="#derivation-of-hylomorphism-combinator" title="Permalink to this headline"></a></h2> <h2>Derivation of <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> combinator<a class="headerlink" href="#derivation-of-hylomorphism-combinator" title="Permalink to this headline"></a></h2>
<p>Now we just need to derive a definition that builds the <code class="docutils literal notranslate"><span class="pre">genrec</span></code> <p>Now we just need to derive a definition that builds the <code class="docutils literal notranslate"><span class="pre">genrec</span></code>
arguments out of the pieces given to the <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> combinator.</p> arguments out of the pieces given to the <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> combinator.</p>
@ -167,9 +169,9 @@ arguments out of the pieces given to the <code class="docutils literal notransla
</div> </div>
<p>Working in reverse:</p> <p>Working in reverse:</p>
<ul class="simple"> <ul class="simple">
<li>Use <code class="docutils literal notranslate"><span class="pre">swoncat</span></code> twice to decouple <code class="docutils literal notranslate"><span class="pre">[c]</span></code> and <code class="docutils literal notranslate"><span class="pre">[F]</span></code>.</li> <li><p>Use <code class="docutils literal notranslate"><span class="pre">swoncat</span></code> twice to decouple <code class="docutils literal notranslate"><span class="pre">[c]</span></code> and <code class="docutils literal notranslate"><span class="pre">[F]</span></code>.</p></li>
<li>Use <code class="docutils literal notranslate"><span class="pre">unit</span></code> to dequote <code class="docutils literal notranslate"><span class="pre">c</span></code>.</li> <li><p>Use <code class="docutils literal notranslate"><span class="pre">unit</span></code> to dequote <code class="docutils literal notranslate"><span class="pre">c</span></code>.</p></li>
<li>Use <code class="docutils literal notranslate"><span class="pre">dipd</span></code> to untangle <code class="docutils literal notranslate"><span class="pre">[unit</span> <span class="pre">[pop]</span> <span class="pre">swoncat]</span></code> from the givens.</li> <li><p>Use <code class="docutils literal notranslate"><span class="pre">dipd</span></code> to untangle <code class="docutils literal notranslate"><span class="pre">[unit</span> <span class="pre">[pop]</span> <span class="pre">swoncat]</span></code> from the givens.</p></li>
</ul> </ul>
<p>So:</p> <p>So:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span>
@ -183,40 +185,40 @@ the left so we have a definition for <code class="docutils literal notranslate">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">hylomorphism</span> <span class="o">==</span> <span class="p">[</span><span class="n">unit</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span><span class="p">]</span> <span class="n">dipd</span> <span class="p">[</span><span class="n">dip</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">hylomorphism</span> <span class="o">==</span> <span class="p">[</span><span class="n">unit</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="n">swoncat</span><span class="p">]</span> <span class="n">dipd</span> <span class="p">[</span><span class="n">dip</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</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;hylomorphism == [unit [pop] swoncat] dipd [dip] swoncat genrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;hylomorphism == [unit [pop] swoncat] dipd [dip] swoncat genrec&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="section" id="example-finding-triangular-numbers"> <section id="example-finding-triangular-numbers">
<h3>Example: Finding <a class="reference external" href="https://en.wikipedia.org/wiki/Triangular_number">Triangular Numbers</a><a class="headerlink" href="#example-finding-triangular-numbers" title="Permalink to this headline"></a></h3> <h3>Example: Finding <a class="reference external" href="https://en.wikipedia.org/wiki/Triangular_number">Triangular Numbers</a><a class="headerlink" href="#example-finding-triangular-numbers" title="Permalink to this headline"></a></h3>
<p>Let’s write a function that, given a positive integer, returns the sum <p>Let’s write a function that, given a positive integer, returns the sum
of all positive integers less than that one. (In this case the types of all positive integers less than that one. (In this case the types
<code class="docutils literal notranslate"><span class="pre">A</span></code>, <code class="docutils literal notranslate"><span class="pre">B</span></code> and <code class="docutils literal notranslate"><span class="pre">C</span></code> are all <code class="docutils literal notranslate"><span class="pre">int</span></code>.)</p> <code class="docutils literal notranslate"><span class="pre">A</span></code>, <code class="docutils literal notranslate"><span class="pre">B</span></code> and <code class="docutils literal notranslate"><span class="pre">C</span></code> are all <code class="docutils literal notranslate"><span class="pre">int</span></code>.)</p>
<p>To sum a range of integers from 0 to <em>n</em> - 1:</p> <p>To sum a range of integers from 0 to <em>n</em> - 1:</p>
<ul class="simple"> <ul class="simple">
<li><code class="docutils literal notranslate"><span class="pre">[P]</span></code> is <code class="docutils literal notranslate"><span class="pre">[1</span> <span class="pre">&lt;=]</span></code></li> <li><p><code class="docutils literal notranslate"><span class="pre">[P]</span></code> is <code class="docutils literal notranslate"><span class="pre">[1</span> <span class="pre">&lt;=]</span></code></p></li>
<li><code class="docutils literal notranslate"><span class="pre">c</span></code> is <code class="docutils literal notranslate"><span class="pre">0</span></code></li> <li><p><code class="docutils literal notranslate"><span class="pre">c</span></code> is <code class="docutils literal notranslate"><span class="pre">0</span></code></p></li>
<li><code class="docutils literal notranslate"><span class="pre">[G]</span></code> is <code class="docutils literal notranslate"><span class="pre">[--</span> <span class="pre">dup]</span></code></li> <li><p><code class="docutils literal notranslate"><span class="pre">[G]</span></code> is <code class="docutils literal notranslate"><span class="pre">[--</span> <span class="pre">dup]</span></code></p></li>
<li><code class="docutils literal notranslate"><span class="pre">[F]</span></code> is <code class="docutils literal notranslate"><span class="pre">[+]</span></code></li> <li><p><code class="docutils literal notranslate"><span class="pre">[F]</span></code> is <code class="docutils literal notranslate"><span class="pre">[+]</span></code></p></li>
</ul> </ul>
<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;triangular_number == [1 &lt;=] 0 [-- dup] [+] hylomorphism&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;triangular_number == [1 &lt;=] 0 [-- dup] [+] hylomorphism&#39;)
</pre></div> </pre></div>
</div> </div>
<p>Let’s try it:</p> <p>Let’s try it:</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;5 triangular_number&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 triangular_number&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">10</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">10</span>
</pre></div> </pre></div>
</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;[0 1 2 3 4 5 6] [triangular_number] map&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[0 1 2 3 4 5 6] [triangular_number] map&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">0</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">3</span> <span class="mi">6</span> <span class="mi">10</span> <span class="mi">15</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">0</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">3</span> <span class="mi">6</span> <span class="mi">10</span> <span class="mi">15</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="four-specializations"> <section id="four-specializations">
<h2>Four Specializations<a class="headerlink" href="#four-specializations" title="Permalink to this headline"></a></h2> <h2>Four Specializations<a class="headerlink" href="#four-specializations" title="Permalink to this headline"></a></h2>
<p>There are at least four kinds of recursive combinator, depending on two <p>There are at least four kinds of recursive combinator, depending on two
choices. The first choice is whether the combiner function <code class="docutils literal notranslate"><span class="pre">F</span></code> should choices. The first choice is whether the combiner function <code class="docutils literal notranslate"><span class="pre">F</span></code> should
@ -244,7 +246,7 @@ Consider the recursive branches:</p>
</div> </div>
<p>The following four sections illustrate how these work, omitting the <p>The following four sections illustrate how these work, omitting the
predicate evaluation.</p> predicate evaluation.</p>
<div class="section" id="h1"> <section id="h1">
<h3><code class="docutils literal notranslate"><span class="pre">H1</span></code><a class="headerlink" href="#h1" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">H1</span></code><a class="headerlink" href="#h1" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H1</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H1</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
@ -271,8 +273,8 @@ the intermediate results along with the pending combiner functions. When
the base case is reached the last term is replaced by the identity value the base case is reached the last term is replaced by the identity value
<code class="docutils literal notranslate"><span class="pre">c</span></code> and the continuation “collapses” into the final result using the <code class="docutils literal notranslate"><span class="pre">c</span></code> and the continuation “collapses” into the final result using the
combiner <code class="docutils literal notranslate"><span class="pre">F</span></code>.</p> combiner <code class="docutils literal notranslate"><span class="pre">F</span></code>.</p>
</div> </section>
<div class="section" id="h2"> <section id="h2">
<h3><code class="docutils literal notranslate"><span class="pre">H2</span></code><a class="headerlink" href="#h2" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">H2</span></code><a class="headerlink" href="#h2" title="Permalink to this headline"></a></h3>
<p>When you can start with the identity value <code class="docutils literal notranslate"><span class="pre">c</span></code> on the stack and the <p>When you can start with the identity value <code class="docutils literal notranslate"><span class="pre">c</span></code> on the stack and the
combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> can operate as you go using the intermediate results combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> can operate as you go using the intermediate results
@ -297,8 +299,8 @@ reverse order.</p>
... d″ ... d″
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="h3"> <section id="h3">
<h3><code class="docutils literal notranslate"><span class="pre">H3</span></code><a class="headerlink" href="#h3" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">H3</span></code><a class="headerlink" href="#h3" title="Permalink to this headline"></a></h3>
<p>If you examine the traces above you’ll see that the combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> only <p>If you examine the traces above you’ll see that the combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> only
gets to operate on the results of <code class="docutils literal notranslate"><span class="pre">G</span></code>, it never “sees” the first value gets to operate on the results of <code class="docutils literal notranslate"><span class="pre">G</span></code>, it never “sees” the first value
@ -326,8 +328,8 @@ one item instead of two (the b is instead the duplicate of a.)</p>
... d″ ... d″
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="h4"> <section id="h4">
<h3><code class="docutils literal notranslate"><span class="pre">H4</span></code><a class="headerlink" href="#h4" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">H4</span></code><a class="headerlink" href="#h4" title="Permalink to this headline"></a></h3>
<p>And, last but not least, if you can combine as you go, starting with <p>And, last but not least, if you can combine as you go, starting with
<code class="docutils literal notranslate"><span class="pre">c</span></code>, and the combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> needs to work on the current item, this is <code class="docutils literal notranslate"><span class="pre">c</span></code>, and the combiner <code class="docutils literal notranslate"><span class="pre">F</span></code> needs to work on the current item, this is
@ -350,9 +352,9 @@ the form:</p>
... d″ ... d″
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="anamorphism"> <section id="anamorphism">
<h2>Anamorphism<a class="headerlink" href="#anamorphism" title="Permalink to this headline"></a></h2> <h2>Anamorphism<a class="headerlink" href="#anamorphism" title="Permalink to this headline"></a></h2>
<p>An anamorphism can be defined as a hylomorphism that uses <code class="docutils literal notranslate"><span class="pre">[]</span></code> for <p>An anamorphism can be defined as a hylomorphism that uses <code class="docutils literal notranslate"><span class="pre">[]</span></code> for
<code class="docutils literal notranslate"><span class="pre">c</span></code> and <code class="docutils literal notranslate"><span class="pre">swons</span></code> for <code class="docutils literal notranslate"><span class="pre">F</span></code>. An anamorphic function builds a list of <code class="docutils literal notranslate"><span class="pre">c</span></code> and <code class="docutils literal notranslate"><span class="pre">swons</span></code> for <code class="docutils literal notranslate"><span class="pre">F</span></code>. An anamorphic function builds a list of
@ -360,68 +362,68 @@ values.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">A</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</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">swons</span><span class="p">]</span> <span class="n">hylomorphism</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">A</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</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">swons</span><span class="p">]</span> <span class="n">hylomorphism</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="range-et-al-an-example-of-an-anamorphism-is-the-range-function-which-generates-the-list-of-integers-from-0-to-n-1-given-n"> <section id="range-et-al-an-example-of-an-anamorphism-is-the-range-function-which-generates-the-list-of-integers-from-0-to-n-1-given-n">
<h3><code class="docutils literal notranslate"><span class="pre">range</span></code> et. al.&nbsp;An example of an anamorphism is the <code class="docutils literal notranslate"><span class="pre">range</span></code> function which generates the list of integers from 0 to <em>n</em> - 1 given <em>n</em>.<a class="headerlink" href="#range-et-al-an-example-of-an-anamorphism-is-the-range-function-which-generates-the-list-of-integers-from-0-to-n-1-given-n" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">range</span></code> et. al. An example of an anamorphism is the <code class="docutils literal notranslate"><span class="pre">range</span></code> function which generates the list of integers from 0 to <em>n</em> - 1 given <em>n</em>.<a class="headerlink" href="#range-et-al-an-example-of-an-anamorphism-is-the-range-function-which-generates-the-list-of-integers-from-0-to-n-1-given-n" title="Permalink to this headline"></a></h3>
<p>Each of the above variations can be used to make four slightly different <p>Each of the above variations can be used to make four slightly different
<code class="docutils literal notranslate"><span class="pre">range</span></code> functions.</p> <code class="docutils literal notranslate"><span class="pre">range</span></code> functions.</p>
<div class="section" id="range-with-h1"> <section id="range-with-h1">
<h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H1</span></code><a class="headerlink" href="#range-with-h1" title="Permalink to this headline"></a></h4> <h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H1</span></code><a class="headerlink" href="#range-with-h1" title="Permalink to this headline"></a></h4>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H1</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H1</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span>
<span class="o">==</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="p">[]]</span> <span class="p">[</span><span class="o">--</span> <span class="n">dup</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">swons</span><span class="p">]</span> <span class="n">genrec</span> <span class="o">==</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="p">[]]</span> <span class="p">[</span><span class="o">--</span> <span class="n">dup</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">swons</span><span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</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;range == [0 &lt;=] [] [-- dup] [swons] hylomorphism&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;range == [0 &lt;=] [] [-- dup] [swons] hylomorphism&#39;)
</pre></div> </pre></div>
</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;5 range&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 range&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">4</span> <span class="mi">3</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">4</span> <span class="mi">3</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="range-with-h2"> <section id="range-with-h2">
<h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H2</span></code><a class="headerlink" href="#range-with-h2" title="Permalink to this headline"></a></h4> <h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H2</span></code><a class="headerlink" href="#range-with-h2" title="Permalink to this headline"></a></h4>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H2</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">G</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">primrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H2</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="n">G</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">primrec</span>
<span class="o">==</span> <span class="p">[]</span> <span class="n">swap</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="o">--</span> <span class="n">dup</span> <span class="p">[</span><span class="n">swons</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">primrec</span> <span class="o">==</span> <span class="p">[]</span> <span class="n">swap</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[</span><span class="o">--</span> <span class="n">dup</span> <span class="p">[</span><span class="n">swons</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">primrec</span>
</pre></div> </pre></div>
</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;range_reverse == [] swap [0 &lt;=] [pop] [-- dup [swons] dip] primrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;range_reverse == [] swap [0 &lt;=] [pop] [-- dup [swons] dip] primrec&#39;)
</pre></div> </pre></div>
</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;5 range_reverse&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 range_reverse&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">0</span> <span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">0</span> <span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="range-with-h3"> <section id="range-with-h3">
<h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H3</span></code><a class="headerlink" href="#range-with-h3" title="Permalink to this headline"></a></h4> <h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H3</span></code><a class="headerlink" href="#range-with-h3" title="Permalink to this headline"></a></h4>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H3</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</span><span class="p">]</span> <span class="p">[[</span><span class="n">G</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H3</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</span><span class="p">]</span> <span class="p">[[</span><span class="n">G</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">F</span><span class="p">]</span> <span class="n">genrec</span>
<span class="o">==</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="p">[]]</span> <span class="p">[[</span><span class="o">--</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">swons</span><span class="p">]</span> <span class="n">genrec</span> <span class="o">==</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="p">[]]</span> <span class="p">[[</span><span class="o">--</span><span class="p">]</span> <span class="n">dupdip</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">swons</span><span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</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;ranger == [0 &lt;=] [pop []] [[--] dupdip] [dip swons] genrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;ranger == [0 &lt;=] [pop []] [[--] dupdip] [dip swons] genrec&#39;)
</pre></div> </pre></div>
</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;5 ranger&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 ranger&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">5</span> <span class="mi">4</span> <span class="mi">3</span> <span class="mi">2</span> <span class="mi">1</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">5</span> <span class="mi">4</span> <span class="mi">3</span> <span class="mi">2</span> <span class="mi">1</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="range-with-h4"> <section id="range-with-h4">
<h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H4</span></code><a class="headerlink" href="#range-with-h4" title="Permalink to this headline"></a></h4> <h4><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H4</span></code><a class="headerlink" href="#range-with-h4" title="Permalink to this headline"></a></h4>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H4</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">G</span> <span class="p">]</span> <span class="n">primrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H4</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">G</span> <span class="p">]</span> <span class="n">primrec</span>
<span class="o">==</span> <span class="p">[]</span> <span class="n">swap</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">swons</span><span class="p">]</span> <span class="n">dupdip</span> <span class="o">--</span><span class="p">]</span> <span class="n">primrec</span> <span class="o">==</span> <span class="p">[]</span> <span class="n">swap</span> <span class="p">[</span><span class="mi">0</span> <span class="o">&lt;=</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">swons</span><span class="p">]</span> <span class="n">dupdip</span> <span class="o">--</span><span class="p">]</span> <span class="n">primrec</span>
</pre></div> </pre></div>
</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;ranger_reverse == [] swap [0 &lt;=] [pop] [[swons] dupdip --] primrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;ranger_reverse == [] swap [0 &lt;=] [pop] [[swons] dupdip --] primrec&#39;)
</pre></div> </pre></div>
</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;5 ranger_reverse&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 ranger_reverse&#39;)
</pre></div> </pre></div>
</div> </div>
<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">4</span> <span class="mi">5</span><span class="p">]</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">4</span> <span class="mi">5</span><span class="p">]</span>
@ -430,10 +432,10 @@ values.</p>
<p>Hopefully this illustrates the workings of the variations. For more <p>Hopefully this illustrates the workings of the variations. For more
insight you can run the cells using the <code class="docutils literal notranslate"><span class="pre">V()</span></code> function instead of the insight you can run the cells using the <code class="docutils literal notranslate"><span class="pre">V()</span></code> function instead of the
<code class="docutils literal notranslate"><span class="pre">J()</span></code> function to get a trace of the Joy evaluation.</p> <code class="docutils literal notranslate"><span class="pre">J()</span></code> function to get a trace of the Joy evaluation.</p>
</div> </section>
</div> </section>
</div> </section>
<div class="section" id="catamorphism"> <section id="catamorphism">
<h2>Catamorphism<a class="headerlink" href="#catamorphism" title="Permalink to this headline"></a></h2> <h2>Catamorphism<a class="headerlink" href="#catamorphism" title="Permalink to this headline"></a></h2>
<p>A catamorphism can be defined as a hylomorphism that uses <p>A catamorphism can be defined as a hylomorphism that uses
<code class="docutils literal notranslate"><span class="pre">[uncons</span> <span class="pre">swap]</span></code> for <code class="docutils literal notranslate"><span class="pre">[G]</span></code> and <code class="docutils literal notranslate"><span class="pre">[[]</span> <span class="pre">=]</span></code> (or just <code class="docutils literal notranslate"><span class="pre">[not]</span></code>) for the <code class="docutils literal notranslate"><span class="pre">[uncons</span> <span class="pre">swap]</span></code> for <code class="docutils literal notranslate"><span class="pre">[G]</span></code> and <code class="docutils literal notranslate"><span class="pre">[[]</span> <span class="pre">=]</span></code> (or just <code class="docutils literal notranslate"><span class="pre">[not]</span></code>) for the
@ -442,27 +444,27 @@ and makes some new value.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">C</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="n">c</span> <span class="p">[</span><span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">hylomorphism</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">C</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="n">c</span> <span class="p">[</span><span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">hylomorphism</span>
</pre></div> </pre></div>
</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;swuncons == uncons swap&#39;</span><span class="p">)</span> <span class="c1"># Awkward name.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;swuncons == uncons swap&#39;) # Awkward name.
</pre></div> </pre></div>
</div> </div>
<p>An example of a catamorphism is the sum function.</p> <p>An example of a catamorphism is the sum function.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">sum</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="mi">0</span> <span class="p">[</span><span class="n">swuncons</span><span class="p">]</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">hylomorphism</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">sum</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="mi">0</span> <span class="p">[</span><span class="n">swuncons</span><span class="p">]</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">hylomorphism</span>
</pre></div> </pre></div>
</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;sum == [not] 0 [swuncons] [+] hylomorphism&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;sum == [not] 0 [swuncons] [+] hylomorphism&#39;)
</pre></div> </pre></div>
</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;[5 4 3 2 1] sum&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[5 4 3 2 1] sum&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="the-step-combinator"> <section id="the-step-combinator">
<h3>The <code class="docutils literal notranslate"><span class="pre">step</span></code> combinator<a class="headerlink" href="#the-step-combinator" title="Permalink to this headline"></a></h3> <h3>The <code class="docutils literal notranslate"><span class="pre">step</span></code> combinator<a class="headerlink" href="#the-step-combinator" title="Permalink to this headline"></a></h3>
<p>The <code class="docutils literal notranslate"><span class="pre">step</span></code> combinator will usually be better to use than <p>The <code class="docutils literal notranslate"><span class="pre">step</span></code> combinator will usually be better to use than
<code class="docutils literal notranslate"><span class="pre">catamorphism</span></code>.</p> <code class="docutils literal notranslate"><span class="pre">catamorphism</span></code>.</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;[step] help&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[step] help&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Run</span> <span class="n">a</span> <span class="n">quoted</span> <span class="n">program</span> <span class="n">on</span> <span class="n">each</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">a</span> <span class="n">sequence</span><span class="o">.</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Run</span> <span class="n">a</span> <span class="n">quoted</span> <span class="n">program</span> <span class="n">on</span> <span class="n">each</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">a</span> <span class="n">sequence</span><span class="o">.</span>
@ -486,18 +488,18 @@ and makes some new value.</p>
<span class="n">on</span> <span class="n">top</span> <span class="n">of</span> <span class="n">the</span> <span class="n">stack</span><span class="o">.</span> <span class="n">on</span> <span class="n">top</span> <span class="n">of</span> <span class="n">the</span> <span class="n">stack</span><span class="o">.</span>
</pre></div> </pre></div>
</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;sum == 0 swap [+] step&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;sum == 0 swap [+] step&#39;)
</pre></div> </pre></div>
</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;[5 4 3 2 1] sum&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[5 4 3 2 1] sum&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="example-factorial-function"> <section id="example-factorial-function">
<h2>Example: Factorial Function<a class="headerlink" href="#example-factorial-function" title="Permalink to this headline"></a></h2> <h2>Example: Factorial Function<a class="headerlink" href="#example-factorial-function" title="Permalink to this headline"></a></h2>
<p>For the Factorial function:</p> <p>For the Factorial function:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H4</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">G</span><span class="p">]</span> <span class="n">primrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H4</span> <span class="o">==</span> <span class="n">c</span> <span class="n">swap</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span><span class="p">]</span> <span class="p">[[</span><span class="n">F</span><span class="p">]</span> <span class="n">dupdip</span> <span class="n">G</span><span class="p">]</span> <span class="n">primrec</span>
@ -510,17 +512,17 @@ and makes some new value.</p>
<span class="n">P</span> <span class="o">==</span> <span class="mi">1</span> <span class="o">&lt;=</span> <span class="n">P</span> <span class="o">==</span> <span class="mi">1</span> <span class="o">&lt;=</span>
</pre></div> </pre></div>
</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;factorial == 1 swap [1 &lt;=] [pop] [[*] dupdip --] primrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;factorial == 1 swap [1 &lt;=] [pop] [[*] dupdip --] primrec&#39;)
</pre></div> </pre></div>
</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;5 factorial&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;5 factorial&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">120</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">120</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="example-tails"> <section id="example-tails">
<h2>Example: <code class="docutils literal notranslate"><span class="pre">tails</span></code><a class="headerlink" href="#example-tails" title="Permalink to this headline"></a></h2> <h2>Example: <code class="docutils literal notranslate"><span class="pre">tails</span></code><a class="headerlink" href="#example-tails" title="Permalink to this headline"></a></h2>
<p>An example of a paramorphism for lists given in the <a class="reference external" href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.41.125">“Bananas…” <p>An example of a paramorphism for lists given in the <a class="reference external" href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.41.125">“Bananas…”
paper</a> paper</a>
@ -542,37 +544,37 @@ pattern <code class="docutils literal notranslate"><span class="pre">H2</span></
<span class="n">P</span> <span class="o">==</span> <span class="ow">not</span> <span class="n">P</span> <span class="o">==</span> <span class="ow">not</span>
</pre></div> </pre></div>
</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;tails == [] swap [not] [pop] [rest dup [swons] dip] primrec&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;tails == [] swap [not] [pop] [rest dup [swons] dip] primrec&#39;)
</pre></div> </pre></div>
</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;[1 2 3] tails&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1 2 3] tails&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[]</span> <span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span><span class="p">]]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[]</span> <span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span><span class="p">]]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="conclusion-patterns-of-recursion"> <section id="conclusion-patterns-of-recursion">
<h2>Conclusion: Patterns of Recursion<a class="headerlink" href="#conclusion-patterns-of-recursion" title="Permalink to this headline"></a></h2> <h2>Conclusion: Patterns of Recursion<a class="headerlink" href="#conclusion-patterns-of-recursion" title="Permalink to this headline"></a></h2>
<p>Our story so far…</p> <p>Our story so far…</p>
<div class="section" id="hylo-ana-cata"> <section id="hylo-ana-cata">
<h3>Hylo-, Ana-, Cata-<a class="headerlink" href="#hylo-ana-cata" title="Permalink to this headline"></a></h3> <h3>Hylo-, Ana-, Cata-<a class="headerlink" href="#hylo-ana-cata" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span> <span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">H</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</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">dip</span> <span class="n">F</span> <span class="p">]</span> <span class="n">genrec</span>
<span class="n">A</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">]</span> <span class="p">[</span><span class="n">pop</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">dip</span> <span class="n">swap</span> <span class="n">cons</span><span class="p">]</span> <span class="n">genrec</span> <span class="n">A</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">]</span> <span class="p">[</span><span class="n">pop</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">dip</span> <span class="n">swap</span> <span class="n">cons</span><span class="p">]</span> <span class="n">genrec</span>
<span class="n">C</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</span> <span class="p">]</span> <span class="p">[</span><span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">F</span> <span class="p">]</span> <span class="n">genrec</span> <span class="n">C</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="n">pop</span> <span class="n">c</span> <span class="p">]</span> <span class="p">[</span><span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="p">[</span><span class="n">dip</span> <span class="n">F</span> <span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="para"> <section id="para">
<h3>Para-, ?-, ?-<a class="headerlink" href="#para" title="Permalink to this headline"></a></h3> <h3>Para-, ?-, ?-<a class="headerlink" href="#para" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>P == c swap [P ] [pop] [[F ] dupdip G ] primrec <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>P == c swap [P ] [pop] [[F ] dupdip G ] primrec
? == [] swap [P ] [pop] [[swap cons] dupdip G ] primrec ? == [] swap [P ] [pop] [[swap cons] dupdip G ] primrec
? == c swap [not] [pop] [[F ] dupdip uncons swap] primrec ? == c swap [not] [pop] [[F ] dupdip uncons swap] primrec
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="appendix-fun-with-symbols"> <section id="appendix-fun-with-symbols">
<h2>Appendix: Fun with Symbols<a class="headerlink" href="#appendix-fun-with-symbols" title="Permalink to this headline"></a></h2> <h2>Appendix: Fun with Symbols<a class="headerlink" href="#appendix-fun-with-symbols" title="Permalink to this headline"></a></h2>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>|[ (c, F), (G, P) ]| == (|c, F|) • [(G, P)] <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>|[ (c, F), (G, P) ]| == (|c, F|) • [(G, P)]
</pre></div> </pre></div>
@ -584,58 +586,55 @@ Wire”</a></p>
</div> </div>
<p>I think they are having slightly too much fun with the symbols. However, <p>I think they are having slightly too much fun with the symbols. However,
“Too much is always better than not enough.”</p> “Too much is always better than not enough.”</p>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Recursion Combinators</a><ul>
<li><a class="reference internal" href="#designing-recursive-functions">Designing Recursive Functions</a></li>
<li><a class="reference internal" href="#primitive-recursive-functions">Primitive Recursive Functions</a></li>
<li><a class="reference internal" href="#hylomorphism">Hylomorphism</a></li>
<li><a class="reference internal" href="#hylomorphism-in-joy">Hylomorphism in Joy</a></li>
<li><a class="reference internal" href="#derivation-of-hylomorphism-combinator">Derivation of <code class="docutils literal notranslate"><span class="pre">hylomorphism</span></code> combinator</a><ul>
<li><a class="reference internal" href="#example-finding-triangular-numbers">Example: Finding Triangular Numbers</a></li>
</ul> <h3>Navigation</h3>
</li> <ul class="current">
<li><a class="reference internal" href="#four-specializations">Four Specializations</a><ul> <li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li><a class="reference internal" href="#h1"><code class="docutils literal notranslate"><span class="pre">H1</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li><a class="reference internal" href="#h2"><code class="docutils literal notranslate"><span class="pre">H2</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li><a class="reference internal" href="#h3"><code class="docutils literal notranslate"><span class="pre">H3</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li><a class="reference internal" href="#h4"><code class="docutils literal notranslate"><span class="pre">H4</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
</ul> <li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
</li> <li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li><a class="reference internal" href="#anamorphism">Anamorphism</a><ul> <li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li><a class="reference internal" href="#range-et-al-an-example-of-an-anamorphism-is-the-range-function-which-generates-the-list-of-integers-from-0-to-n-1-given-n"><code class="docutils literal notranslate"><span class="pre">range</span></code> et. al.&nbsp;An example of an anamorphism is the <code class="docutils literal notranslate"><span class="pre">range</span></code> function which generates the list of integers from 0 to <em>n</em> - 1 given <em>n</em>.</a><ul> <li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li><a class="reference internal" href="#range-with-h1"><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H1</span></code></a></li> <li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li><a class="reference internal" href="#range-with-h2"><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H2</span></code></a></li> <li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li><a class="reference internal" href="#range-with-h3"><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H3</span></code></a></li> <li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li><a class="reference internal" href="#range-with-h4"><code class="docutils literal notranslate"><span class="pre">range</span></code> with <code class="docutils literal notranslate"><span class="pre">H4</span></code></a></li> <li class="toctree-l2 current"><a class="current reference internal" href="#">Recursion Combinators</a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li><a class="reference internal" href="#catamorphism">Catamorphism</a><ul> <li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li><a class="reference internal" href="#the-step-combinator">The <code class="docutils literal notranslate"><span class="pre">step</span></code> combinator</a></li> <li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li><a class="reference internal" href="#example-factorial-function">Example: Factorial Function</a></li> <li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li><a class="reference internal" href="#example-tails">Example: <code class="docutils literal notranslate"><span class="pre">tails</span></code></a></li> <li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li><a class="reference internal" href="#conclusion-patterns-of-recursion">Conclusion: Patterns of Recursion</a><ul> <li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
<li><a class="reference internal" href="#hylo-ana-cata">Hylo-, Ana-, Cata-</a></li>
<li><a class="reference internal" href="#para">Para-, ?-, ?-</a></li>
</ul>
</li>
<li><a class="reference internal" href="#appendix-fun-with-symbols">Appendix: Fun with Symbols</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -647,25 +646,24 @@ Wire”</a></p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Recursion_Combinators.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -676,7 +674,7 @@ Wire”</a></p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

139
docs/sphinx_docs/_build/html/notebooks/Replacing.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Replacing Functions in the Dictionary &#8212; Thun 0.4.1 documentation</title> <title>Replacing Functions in the Dictionary &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Recursion Combinators" href="Recursion_Combinators.html" /> <link rel="next" title="Recursion Combinators" href="Recursion_Combinators.html" />
@ -30,23 +29,25 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="replacing-functions-in-the-dictionary"> <section id="replacing-functions-in-the-dictionary">
<h1>Replacing Functions in the Dictionary<a class="headerlink" href="#replacing-functions-in-the-dictionary" title="Permalink to this headline"></a></h1> <h1>Replacing Functions in the Dictionary<a class="headerlink" href="#replacing-functions-in-the-dictionary" title="Permalink to this headline"></a></h1>
<p>For now, there is no way to define new functions from within the Joy <p>For now, there is no way to define new functions from within the Joy
language. All functions (and the interpreter) all accept and return a language. All functions (and the interpreter) all accept and return a
dictionary parameter (in addition to the stack and expression) so that dictionary parameter (in addition to the stack and expression) so that
we can implement e.g.&nbsp;a function that adds new functions to the we can implement e.g. a function that adds new functions to the
dictionary. However, there’s no function that does that. Adding a new dictionary. However, there’s no function that does that. Adding a new
function to the dictionary is a meta-interpreter action, you have to do function to the dictionary is a meta-interpreter action, you have to do
it in Python, not Joy.</p> it in Python, not Joy.</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">D</span><span class="p">,</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import D, J, V
</pre></div> </pre></div>
</div> </div>
<div class="section" id="a-long-trace"> <section id="a-long-trace">
<h2>A long trace<a class="headerlink" href="#a-long-trace" title="Permalink to this headline"></a></h2> <h2>A long trace<a class="headerlink" href="#a-long-trace" title="Permalink to this headline"></a></h2>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[23 18] average&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[23 18] average&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span>
@ -93,8 +94,8 @@ it in Python, not Joy.</p>
<span class="mf">20.5</span> <span class="o">.</span> <span class="mf">20.5</span> <span class="o">.</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="replacing-size-with-a-python-version"> <section id="replacing-size-with-a-python-version">
<h2>Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python version<a class="headerlink" href="#replacing-size-with-a-python-version" title="Permalink to this headline"></a></h2> <h2>Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python version<a class="headerlink" href="#replacing-size-with-a-python-version" title="Permalink to this headline"></a></h2>
<p>Both <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> each convert a sequence to a single value.</p> <p>Both <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> each convert a sequence to a single value.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="nb">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">step</span> <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>
@ -104,30 +105,30 @@ it in Python, not Joy.</p>
<p>An efficient <code class="docutils literal notranslate"><span class="pre">sum</span></code> function is already in the library. But for <p>An efficient <code class="docutils literal notranslate"><span class="pre">sum</span></code> function is already in the library. But for
<code class="docutils literal notranslate"><span class="pre">size</span></code> we can use a “compiled” version hand-written in Python to speed <code class="docutils literal notranslate"><span class="pre">size</span></code> we can use a “compiled” version hand-written in Python to speed
up evaluation and make the trace more readable.</p> up evaluation and make the trace more readable.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="k">import</span> <span class="n">SimpleFunctionWrapper</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from joy.library import SimpleFunctionWrapper
<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="k">import</span> <span class="n">iter_stack</span> from joy.utils.stack import iter_stack
<span class="nd">@SimpleFunctionWrapper</span> @SimpleFunctionWrapper
<span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> def size(stack):
<span class="sd">&#39;&#39;&#39;Return the size of the sequence on the stack.&#39;&#39;&#39;</span> &#39;&#39;&#39;Return the size of the sequence on the stack.&#39;&#39;&#39;
<span class="n">sequence</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span> sequence, stack = stack
<span class="n">n</span> <span class="o">=</span> <span class="mi">0</span> n = 0
<span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">sequence</span><span class="p">):</span> for _ in iter_stack(sequence):
<span class="n">n</span> <span class="o">+=</span> <span class="mi">1</span> n += 1
<span class="k">return</span> <span class="n">n</span><span class="p">,</span> <span class="n">stack</span> return n, stack
</pre></div> </pre></div>
</div> </div>
<p>Now we replace the old version in the dictionary with the new version, <p>Now we replace the old version in the dictionary with the new version,
and re-evaluate the expression.</p> and re-evaluate the expression.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">D</span><span class="p">[</span><span class="s1">&#39;size&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">size</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>D[&#39;size&#39;] = size
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="a-shorter-trace"> <section id="a-shorter-trace">
<h2>A shorter trace<a class="headerlink" href="#a-shorter-trace" title="Permalink to this headline"></a></h2> <h2>A shorter trace<a class="headerlink" href="#a-shorter-trace" title="Permalink to this headline"></a></h2>
<p>You can see that <code class="docutils literal notranslate"><span class="pre">size</span></code> now executes in a single step.</p> <p>You can see that <code class="docutils literal notranslate"><span class="pre">size</span></code> now executes in a single step.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[23 18] average&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[23 18] average&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">23</span> <span class="mi">18</span><span class="p">]</span> <span class="n">average</span>
@ -161,24 +162,55 @@ and re-evaluate the expression.</p>
<span class="mf">20.5</span> <span class="o">.</span> <span class="mf">20.5</span> <span class="o">.</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Replacing Functions in the Dictionary</a><ul>
<li><a class="reference internal" href="#a-long-trace">A long trace</a></li>
<li><a class="reference internal" href="#replacing-size-with-a-python-version">Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python version</a></li>
<li><a class="reference internal" href="#a-shorter-trace">A shorter trace</a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -190,25 +222,24 @@ and re-evaluate the expression.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Replacing.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -219,7 +250,7 @@ and re-evaluate the expression.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

179
docs/sphinx_docs/_build/html/notebooks/The_Four_Operations.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>The Four Fundamental Operations of Definite Action &#8212; Thun 0.4.1 documentation</title> <title>The Four Fundamental Operations of Definite Action &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="∂RE" href="Derivatives_of_Regular_Expressions.html" /> <link rel="next" title="∂RE" href="Derivatives_of_Regular_Expressions.html" />
@ -30,19 +29,21 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="the-four-fundamental-operations-of-definite-action"> <section id="the-four-fundamental-operations-of-definite-action">
<h1>The Four Fundamental Operations of Definite Action<a class="headerlink" href="#the-four-fundamental-operations-of-definite-action" title="Permalink to this headline"></a></h1> <h1>The Four Fundamental Operations of Definite Action<a class="headerlink" href="#the-four-fundamental-operations-of-definite-action" title="Permalink to this headline"></a></h1>
<p>All definite actions (computer program) can be defined by four <p>All definite actions (computer program) can be defined by four
fundamental patterns of combination:</p> fundamental patterns of combination:</p>
<ol class="arabic simple"> <ol class="arabic simple">
<li>Sequence</li> <li><p>Sequence</p></li>
<li>Branch</li> <li><p>Branch</p></li>
<li>Loop</li> <li><p>Loop</p></li>
<li>Parallel</li> <li><p>Parallel</p></li>
</ol> </ol>
<div class="section" id="sequence"> <section id="sequence">
<h2>Sequence<a class="headerlink" href="#sequence" title="Permalink to this headline"></a></h2> <h2>Sequence<a class="headerlink" href="#sequence" title="Permalink to this headline"></a></h2>
<p>Do one thing after another. In joy this is represented by putting two <p>Do one thing after another. In joy this is represented by putting two
symbols together, juxtaposition:</p> symbols together, juxtaposition:</p>
@ -51,8 +52,8 @@ symbols together, juxtaposition:</p>
</div> </div>
<p>Operations have inputs and outputs. The outputs of <code class="docutils literal notranslate"><span class="pre">foo</span></code> must be <p>Operations have inputs and outputs. The outputs of <code class="docutils literal notranslate"><span class="pre">foo</span></code> must be
compatible in “arity”, type, and shape with the inputs of <code class="docutils literal notranslate"><span class="pre">bar</span></code>.</p> compatible in “arity”, type, and shape with the inputs of <code class="docutils literal notranslate"><span class="pre">bar</span></code>.</p>
</div> </section>
<div class="section" id="branch"> <section id="branch">
<h2>Branch<a class="headerlink" href="#branch" title="Permalink to this headline"></a></h2> <h2>Branch<a class="headerlink" href="#branch" title="Permalink to this headline"></a></h2>
<p>Do one thing or another.</p> <p>Do one thing or another.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">boolean</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="n">boolean</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>
@ -93,7 +94,7 @@ outputs for <code class="docutils literal notranslate"><span class="pre">foo</sp
<span class="n">foo</span> <span class="n">T</span> <span class="n">bar</span> <span class="n">foo</span> <span class="n">T</span> <span class="n">bar</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="ifte"> <section id="ifte">
<h3><code class="docutils literal notranslate"><span class="pre">ifte</span></code><a class="headerlink" href="#ifte" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">ifte</span></code><a class="headerlink" href="#ifte" title="Permalink to this headline"></a></h3>
<p>Often it will be easier on the programmer to write branching code with <p>Often it will be easier on the programmer to write branching code with
the predicate specified in a quote. The <code class="docutils literal notranslate"><span class="pre">ifte</span></code> combinator provides the predicate specified in a quote. The <code class="docutils literal notranslate"><span class="pre">ifte</span></code> combinator provides
@ -115,9 +116,9 @@ evaluate it. I reflect this in the structure of the stack effect comment
of <code class="docutils literal notranslate"><span class="pre">branch</span></code>, it will only accept Boolean values, and in the definition of <code class="docutils literal notranslate"><span class="pre">branch</span></code>, it will only accept Boolean values, and in the definition
of <code class="docutils literal notranslate"><span class="pre">ifte</span></code> above by including <code class="docutils literal notranslate"><span class="pre">not</span></code> in the quote, which also has the of <code class="docutils literal notranslate"><span class="pre">ifte</span></code> above by including <code class="docutils literal notranslate"><span class="pre">not</span></code> in the quote, which also has the
effect that the subject quotes are in the proper order for <code class="docutils literal notranslate"><span class="pre">branch</span></code>.)</p> effect that the subject quotes are in the proper order for <code class="docutils literal notranslate"><span class="pre">branch</span></code>.)</p>
</div> </section>
</div> </section>
<div class="section" id="loop"> <section id="loop">
<h2>Loop<a class="headerlink" href="#loop" title="Permalink to this headline"></a></h2> <h2>Loop<a class="headerlink" href="#loop" title="Permalink to this headline"></a></h2>
<p>Do one thing zero or more times.</p> <p>Do one thing zero or more times.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">boolean</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="n">boolean</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
@ -168,7 +169,7 @@ boolean flag for the next iteration:</p>
<span class="n">G</span> <span class="n">G</span> <span class="n">G</span> <span class="n">G</span> <span class="n">G</span> <span class="n">G</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="while"> <section id="while">
<h3><code class="docutils literal notranslate"><span class="pre">while</span></code><a class="headerlink" href="#while" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">while</span></code><a class="headerlink" href="#while" title="Permalink to this headline"></a></h3>
<p>Keep doing <code class="docutils literal notranslate"><span class="pre">B</span></code> <em>while</em> some predicate <code class="docutils literal notranslate"><span class="pre">P</span></code> is true. This is <p>Keep doing <code class="docutils literal notranslate"><span class="pre">B</span></code> <em>while</em> some predicate <code class="docutils literal notranslate"><span class="pre">P</span></code> is true. This is
convenient as the predicate function is made nullary automatically and convenient as the predicate function is made nullary automatically and
@ -191,9 +192,9 @@ flag for the next iteration:</p>
<span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">nullary</span> <span class="p">[</span><span class="n">B</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">nullary</span><span class="p">]</span> <span class="n">loop</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">nullary</span> <span class="p">[</span><span class="n">B</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">nullary</span><span class="p">]</span> <span class="n">loop</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="parallel"> <section id="parallel">
<h2>Parallel<a class="headerlink" href="#parallel" title="Permalink to this headline"></a></h2> <h2>Parallel<a class="headerlink" href="#parallel" title="Permalink to this headline"></a></h2>
<p>The <em>parallel</em> operation indicates that two (or more) functions <em>do not <p>The <em>parallel</em> operation indicates that two (or more) functions <em>do not
interfere</em> with each other and so can run in parallel. The main interfere</em> with each other and so can run in parallel. The main
@ -201,10 +202,10 @@ difficulty in this sort of thing is orchestrating the recombining
(“join” or “wait”) of the results of the functions after they finish.</p> (“join” or “wait”) of the results of the functions after they finish.</p>
<p>The current implementaions and the following definitions <em>are not <p>The current implementaions and the following definitions <em>are not
actually parallel</em> (yet), but there is no reason they couldn’t be actually parallel</em> (yet), but there is no reason they couldn’t be
reimplemented in terms of e.g.&nbsp;Python threads. I am not concerned with reimplemented in terms of e.g. Python threads. I am not concerned with
performance of the system just yet, only the elegance of the code it performance of the system just yet, only the elegance of the code it
allows us to write.</p> allows us to write.</p>
<div class="section" id="cleave"> <section id="cleave">
<h3><code class="docutils literal notranslate"><span class="pre">cleave</span></code><a class="headerlink" href="#cleave" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">cleave</span></code><a class="headerlink" href="#cleave" title="Permalink to this headline"></a></h3>
<p>Joy has a few parallel combinators, the main one being <code class="docutils literal notranslate"><span class="pre">cleave</span></code>:</p> <p>Joy has a few parallel combinators, the main one being <code class="docutils literal notranslate"><span class="pre">cleave</span></code>:</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">A</span><span class="p">]</span> <span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="n">cleave</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">A</span><span class="p">]</span> <span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="n">cleave</span>
@ -225,8 +226,8 @@ Elliott’s “Compiling to Categories” paper, et. al.)</p>
<p>Just a thought, if you <code class="docutils literal notranslate"><span class="pre">cleave</span></code> two jobs and one requires more time to <p>Just a thought, if you <code class="docutils literal notranslate"><span class="pre">cleave</span></code> two jobs and one requires more time to
finish than the other you’d like to be able to assign resources finish than the other you’d like to be able to assign resources
accordingly so that they both finish at the same time.</p> accordingly so that they both finish at the same time.</p>
</div> </section>
<div class="section" id="apply-functions"> <section id="apply-functions">
<h3>“Apply” Functions<a class="headerlink" href="#apply-functions" title="Permalink to this headline"></a></h3> <h3>“Apply” Functions<a class="headerlink" href="#apply-functions" title="Permalink to this headline"></a></h3>
<p>There are also <code class="docutils literal notranslate"><span class="pre">app2</span></code> and <code class="docutils literal notranslate"><span class="pre">app3</span></code> which run a single quote on more <p>There are also <code class="docutils literal notranslate"><span class="pre">app2</span></code> and <code class="docutils literal notranslate"><span class="pre">app3</span></code> which run a single quote on more
than one value:</p> than one value:</p>
@ -257,8 +258,8 @@ value.)</p>
<span class="n">a</span> <span class="n">b</span> <span class="n">a</span> <span class="n">b</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="map"> <section id="map">
<h3><code class="docutils literal notranslate"><span class="pre">map</span></code><a class="headerlink" href="#map" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">map</span></code><a class="headerlink" href="#map" title="Permalink to this headline"></a></h3>
<p>The common <code class="docutils literal notranslate"><span class="pre">map</span></code> function in Joy should also be though of as a <p>The common <code class="docutils literal notranslate"><span class="pre">map</span></code> function in Joy should also be though of as a
<em>parallel</em> operator:</p> <em>parallel</em> operator:</p>
@ -266,9 +267,9 @@ value.)</p>
</pre></div> </pre></div>
</div> </div>
<p>There is no reason why the implementation of <code class="docutils literal notranslate"><span class="pre">map</span></code> couldn’t distribute <p>There is no reason why the implementation of <code class="docutils literal notranslate"><span class="pre">map</span></code> couldn’t distribute
the <code class="docutils literal notranslate"><span class="pre">Q</span></code> function over e.g.&nbsp;a pool of worker CPUs.</p> the <code class="docutils literal notranslate"><span class="pre">Q</span></code> function over e.g. a pool of worker CPUs.</p>
</div> </section>
<div class="section" id="pam"> <section id="pam">
<h3><code class="docutils literal notranslate"><span class="pre">pam</span></code><a class="headerlink" href="#pam" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">pam</span></code><a class="headerlink" href="#pam" title="Permalink to this headline"></a></h3>
<p>One of my favorite combinators, the <code class="docutils literal notranslate"><span class="pre">pam</span></code> combinator is just:</p> <p>One of my favorite combinators, the <code class="docutils literal notranslate"><span class="pre">pam</span></code> combinator is just:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pam</span> <span class="o">==</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="nb">map</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pam</span> <span class="o">==</span> <span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="nb">map</span>
@ -281,21 +282,21 @@ stack and combine their (first) outputs in a result list.</p>
<span class="p">[</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="o">...</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="o">...</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="handling-other-kinds-of-join"> <section id="handling-other-kinds-of-join">
<h3>Handling Other Kinds of Join<a class="headerlink" href="#handling-other-kinds-of-join" title="Permalink to this headline"></a></h3> <h3>Handling Other Kinds of Join<a class="headerlink" href="#handling-other-kinds-of-join" title="Permalink to this headline"></a></h3>
<p>The <code class="docutils literal notranslate"><span class="pre">cleave</span></code> operators and others all have pretty brutal join <p>The <code class="docutils literal notranslate"><span class="pre">cleave</span></code> operators and others all have pretty brutal join
semantics: everything works and we always wait for every semantics: everything works and we always wait for every
sub-computation. We can imagine a few different potentially useful sub-computation. We can imagine a few different potentially useful
patterns of “joining” results from parallel combinators.</p> patterns of “joining” results from parallel combinators.</p>
<div class="section" id="first-to-finish"> <section id="first-to-finish">
<h4>first-to-finish<a class="headerlink" href="#first-to-finish" title="Permalink to this headline"></a></h4> <h4>first-to-finish<a class="headerlink" href="#first-to-finish" title="Permalink to this headline"></a></h4>
<p>Thinking about variations of <code class="docutils literal notranslate"><span class="pre">pam</span></code> there could be one that only <p>Thinking about variations of <code class="docutils literal notranslate"><span class="pre">pam</span></code> there could be one that only
returns the first result of the first-to-finish sub-program, or the returns the first result of the first-to-finish sub-program, or the
stack could be replaced by its output stack.</p> stack could be replaced by its output stack.</p>
<p>The other sub-programs would be cancelled.</p> <p>The other sub-programs would be cancelled.</p>
</div> </section>
<div class="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. “Fulinators”
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
@ -312,44 +313,57 @@ with “asyncronous” … events?</p>
sort of thing works perfectly in Joy code I’m not going to worry about sort of thing works perfectly in Joy code I’m not going to worry about
it. (And I think the Categories can deal with it anyhow? Incremental it. (And I think the Categories can deal with it anyhow? Incremental
evaluation, yeah?)</p> evaluation, yeah?)</p>
</div> </section>
</div> </section>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">The Four Fundamental Operations of Definite Action</a><ul>
<li><a class="reference internal" href="#sequence">Sequence</a></li>
<li><a class="reference internal" href="#branch">Branch</a><ul>
<li><a class="reference internal" href="#ifte"><code class="docutils literal notranslate"><span class="pre">ifte</span></code></a></li>
</ul>
</li>
<li><a class="reference internal" href="#loop">Loop</a><ul>
<li><a class="reference internal" href="#while"><code class="docutils literal notranslate"><span class="pre">while</span></code></a></li> <h3>Navigation</h3>
</ul> <ul class="current">
</li> <li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li><a class="reference internal" href="#parallel">Parallel</a><ul> <li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li><a class="reference internal" href="#cleave"><code class="docutils literal notranslate"><span class="pre">cleave</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li><a class="reference internal" href="#apply-functions">“Apply” Functions</a></li> <li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li><a class="reference internal" href="#map"><code class="docutils literal notranslate"><span class="pre">map</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li><a class="reference internal" href="#pam"><code class="docutils literal notranslate"><span class="pre">pam</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li><a class="reference internal" href="#handling-other-kinds-of-join">Handling Other Kinds of Join</a><ul> <li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li><a class="reference internal" href="#first-to-finish">first-to-finish</a></li> <li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li><a class="reference internal" href="#fulminators">“Fulminators”</a></li> <li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
</ul> <li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -361,25 +375,24 @@ evaluation, yeah?)</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/The_Four_Operations.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -390,7 +403,7 @@ evaluation, yeah?)</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

265
docs/sphinx_docs/_build/html/notebooks/Treestep.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Treating Trees II: treestep &#8212; Thun 0.4.1 documentation</title> <title>Treating Trees II: treestep &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Using x to Generate Values" href="Generator_Programs.html" /> <link rel="next" title="Using x to Generate Values" href="Generator_Programs.html" />
@ -30,9 +29,11 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="treating-trees-ii-treestep"> <section id="treating-trees-ii-treestep">
<h1>Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#treating-trees-ii-treestep" title="Permalink to this headline"></a></h1> <h1>Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#treating-trees-ii-treestep" title="Permalink to this headline"></a></h1>
<p>Let’s consider a tree structure, similar to one described <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why <p>Let’s consider a tree structure, similar to one described <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why
functional programming matters” by John functional programming matters” by John
@ -65,7 +66,7 @@ combine the result with <code class="docutils literal notranslate"><span class="
</div> </div>
<p>(Later on we’ll experiment with making <code class="docutils literal notranslate"><span class="pre">map</span></code> part of <code class="docutils literal notranslate"><span class="pre">C</span></code> so you can <p>(Later on we’ll experiment with making <code class="docutils literal notranslate"><span class="pre">map</span></code> part of <code class="docutils literal notranslate"><span class="pre">C</span></code> so you can
use other combinators.)</p> use other combinators.)</p>
<div class="section" id="derive-the-recursive-function"> <section id="derive-the-recursive-function">
<h2>Derive the recursive function.<a class="headerlink" href="#derive-the-recursive-function" title="Permalink to this headline"></a></h2> <h2>Derive the recursive function.<a class="headerlink" href="#derive-the-recursive-function" title="Permalink to this headline"></a></h2>
<p>We can begin to derive it by finding the <code class="docutils literal notranslate"><span class="pre">ifte</span></code> stage that <code class="docutils literal notranslate"><span class="pre">genrec</span></code> <p>We can begin to derive it by finding the <code class="docutils literal notranslate"><span class="pre">ifte</span></code> stage that <code class="docutils literal notranslate"><span class="pre">genrec</span></code>
will produce.</p> will produce.</p>
@ -110,8 +111,8 @@ the desired outcome.</p>
<span class="o">==</span> <span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span> <span class="o">==</span> <span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="extract-the-givens-to-parameterize-the-program"> <section id="extract-the-givens-to-parameterize-the-program">
<h2>Extract the givens to parameterize the program.<a class="headerlink" href="#extract-the-givens-to-parameterize-the-program" title="Permalink to this headline"></a></h2> <h2>Extract the givens to parameterize the program.<a class="headerlink" href="#extract-the-givens-to-parameterize-the-program" title="Permalink to this headline"></a></h2>
<p>Working backwards:</p> <p>Working backwards:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
@ -134,7 +135,7 @@ the desired outcome.</p>
</pre></div> </pre></div>
</div> </div>
<p>The givens are all to the left so we have our definition.</p> <p>The givens are all to the left so we have our definition.</p>
<div class="section" id="alternate-extract-the-givens-to-parameterize-the-program"> <section id="alternate-extract-the-givens-to-parameterize-the-program">
<h3>(alternate) Extract the givens to parameterize the program.<a class="headerlink" href="#alternate-extract-the-givens-to-parameterize-the-program" title="Permalink to this headline"></a></h3> <h3>(alternate) Extract the givens to parameterize the program.<a class="headerlink" href="#alternate-extract-the-givens-to-parameterize-the-program" title="Permalink to this headline"></a></h3>
<p>Working backwards:</p> <p>Working backwards:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="ow">not</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">uncons</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="nb">map</span> <span class="n">C</span><span class="p">]</span> <span class="n">genrec</span>
@ -143,32 +144,32 @@ the desired outcome.</p>
<span class="o">^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^</span> <span class="o">^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="define-treestep"> <section id="define-treestep">
<h2>Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#define-treestep" title="Permalink to this headline"></a></h2> <h2>Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code><a class="headerlink" href="#define-treestep" title="Permalink to this headline"></a></h2>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">D</span><span class="p">,</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span><span class="p">,</span> <span class="n">define</span><span class="p">,</span> <span class="n">DefinitionWrapper</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import D, J, V, define, DefinitionWrapper
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>DefinitionWrapper.add_definitions(&#39;&#39;&#39;
<span class="s1"> _treestep_0 == [[not] swap] dip</span> _treestep_0 == [[not] swap] dip
<span class="s1"> _treestep_1 == [dip] cons [uncons] swoncat</span> _treestep_1 == [dip] cons [uncons] swoncat
<span class="s1"> treegrind == [_treestep_1 _treestep_0] dip genrec</span> treegrind == [_treestep_1 _treestep_0] dip genrec
<span class="s1"> treestep == [map] swoncat treegrind</span> treestep == [map] swoncat treegrind
<span class="s1">&#39;&#39;&#39;</span><span class="p">,</span> <span class="n">D</span><span class="p">)</span> &#39;&#39;&#39;, D)
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="examples"> <section id="examples">
<h2>Examples<a class="headerlink" href="#examples" title="Permalink to this headline"></a></h2> <h2>Examples<a class="headerlink" href="#examples" title="Permalink to this headline"></a></h2>
<p>Consider trees, the nodes of which are integers. We can find the sum of <p>Consider trees, the nodes of which are integers. We can find the sum of
all nodes in a tree with this function:</p> all nodes in a tree with this function:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sumtree</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[</span><span class="nb">sum</span> <span class="o">+</span><span class="p">]</span> <span class="n">treestep</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sumtree</span> <span class="o">==</span> <span class="p">[</span><span class="n">pop</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[</span><span class="nb">sum</span> <span class="o">+</span><span class="p">]</span> <span class="n">treestep</span>
</pre></div> </pre></div>
</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;sumtree == [pop 0] [] [sum +] treestep&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;sumtree == [pop 0] [] [sum +] treestep&#39;)
</pre></div> </pre></div>
</div> </div>
<p>Running this function on an empty tree value gives zero:</p> <p>Running this function on an empty tree value gives zero:</p>
@ -177,7 +178,7 @@ all nodes in a tree with this function:</p>
<span class="mi">0</span> <span class="mi">0</span>
</pre></div> </pre></div>
</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;[] sumtree&#39;</span><span class="p">)</span> <span class="c1"># Empty tree.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[] sumtree&#39;) # Empty tree.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">0</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">0</span>
@ -191,68 +192,68 @@ all nodes in a tree with this function:</p>
<span class="n">n</span><span class="o">+</span><span class="n">m</span> <span class="n">n</span><span class="o">+</span><span class="n">m</span>
</pre></div> </pre></div>
</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] sumtree&#39;</span><span class="p">)</span> <span class="c1"># No child trees.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23] sumtree&#39;) # No child trees.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span>
</pre></div> </pre></div>
</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 []] sumtree&#39;</span><span class="p">)</span> <span class="c1"># Child tree, empty.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 []] sumtree&#39;) # Child tree, empty.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span>
</pre></div> </pre></div>
</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 [2 [4]] [3]] sumtree&#39;</span><span class="p">)</span> <span class="c1"># Non-empty child trees.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [4]] [3]] sumtree&#39;) # Non-empty child trees.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">32</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">32</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] sumtree&#39;</span><span class="p">)</span> <span class="c1"># Etc...</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] sumtree&#39;) # Etc...
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">49</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">49</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] [pop 0] [] [cons sum] treestep&#39;</span><span class="p">)</span> <span class="c1"># Alternate &quot;spelling&quot;.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] [pop 0] [] [cons sum] treestep&#39;) # Alternate &quot;spelling&quot;.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">49</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">49</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] [] [pop 23] [cons] treestep&#39;</span><span class="p">)</span> <span class="c1"># Replace each node.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] [] [pop 23] [cons] treestep&#39;) # Replace each node.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">23</span> <span class="p">[</span><span class="mi">23</span> <span class="p">[</span><span class="mi">23</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span><span class="p">]]</span> <span class="p">[</span><span class="mi">23</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="p">[]]]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">23</span> <span class="p">[</span><span class="mi">23</span> <span class="p">[</span><span class="mi">23</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span><span class="p">]]</span> <span class="p">[</span><span class="mi">23</span><span class="p">]</span> <span class="p">[</span><span class="mi">23</span> <span class="p">[]]]</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep&#39;)
</pre></div> </pre></div>
</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="mi">1</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span><span class="p">]]</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="p">[]]]</span> <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="mi">1</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span><span class="p">]]</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="p">[]]]</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep sumtree&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] [] [pop 1] [cons] treestep sumtree&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">6</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">6</span>
</pre></div> </pre></div>
</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 [2 [8] [9]] [3] [4 []]] [pop 0] [pop 1] [sum +] treestep&#39;</span><span class="p">)</span> <span class="c1"># Combine replace and sum into one function.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[23 [2 [8] [9]] [3] [4 []]] [pop 0] [pop 1] [sum +] treestep&#39;) # Combine replace and sum into one function.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">6</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">6</span>
</pre></div> </pre></div>
</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;[4 [3 [] [7]]] [pop 0] [pop 1] [sum +] treestep&#39;</span><span class="p">)</span> <span class="c1"># Combine replace and sum into one function.</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[4 [3 [] [7]]] [pop 0] [pop 1] [sum +] treestep&#39;) # Combine replace and sum into one function.
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="redefining-the-ordered-binary-tree-in-terms-of-treestep"> <section id="redefining-the-ordered-binary-tree-in-terms-of-treestep">
<h2>Redefining the Ordered Binary Tree in terms of <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.<a class="headerlink" href="#redefining-the-ordered-binary-tree-in-terms-of-treestep" title="Permalink to this headline"></a></h2> <h2>Redefining the Ordered Binary Tree in terms of <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.<a class="headerlink" href="#redefining-the-ordered-binary-tree-in-terms-of-treestep" title="Permalink to this headline"></a></h2>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Tree</span> <span class="o">=</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Tree</span> <span class="o">=</span> <span class="p">[]</span> <span class="o">|</span> <span class="p">[[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">left</span> <span class="n">right</span><span class="p">]</span>
</pre></div> </pre></div>
@ -266,7 +267,7 @@ all nodes in a tree with this function:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">C</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="traversal"> <section id="traversal">
<h3>Traversal<a class="headerlink" href="#traversal" title="Permalink to this headline"></a></h3> <h3>Traversal<a class="headerlink" href="#traversal" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">first</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">first</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span>
<span class="n">key</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span> <span class="n">key</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="nb">map</span> <span class="n">i</span>
@ -276,7 +277,7 @@ all nodes in a tree with this function:</p>
</pre></div> </pre></div>
</div> </div>
<p>This doesn’t quite work:</p> <p>This doesn’t quite work:</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;[[3 0] [[2 0] [][]] [[9 0] [[5 0] [[4 0] [][]] [[8 0] [[6 0] [] [[7 0] [][]]][]]][]]] [&quot;B&quot;] [first] [i] treestep&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[3 0] [[2 0] [][]] [[9 0] [[5 0] [[4 0] [][]] [[8 0] [[6 0] [] [[7 0] [][]]][]]][]]] [&quot;B&quot;] [first] [i] treestep&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span> <span class="s1">&#39;B&#39;</span> <span class="s1">&#39;B&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span> <span class="s1">&#39;B&#39;</span> <span class="s1">&#39;B&#39;</span>
@ -298,15 +299,15 @@ depositing our results directly on the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="p">[</span><span class="n">flatten</span> <span class="n">cons</span><span class="p">]</span> <span class="n">treestep</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="p">[</span><span class="n">flatten</span> <span class="n">cons</span><span class="p">]</span> <span class="n">treestep</span>
</pre></div> </pre></div>
</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;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [first] [flatten cons] treestep&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [first] [flatten cons] treestep&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">2</span> <span class="mi">9</span> <span class="mi">5</span> <span class="mi">4</span> <span class="mi">8</span> <span class="mi">6</span> <span class="mi">7</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">2</span> <span class="mi">9</span> <span class="mi">5</span> <span class="mi">4</span> <span class="mi">8</span> <span class="mi">6</span> <span class="mi">7</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
<p>There we go.</p> <p>There we go.</p>
</div> </section>
<div class="section" id="in-order-traversal"> <section id="in-order-traversal">
<h3>In-order traversal<a class="headerlink" href="#in-order-traversal" title="Permalink to this headline"></a></h3> <h3>In-order traversal<a class="headerlink" href="#in-order-traversal" title="Permalink to this headline"></a></h3>
<p>From here:</p> <p>From here:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="p">[[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]]</span> <span class="n">C</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">key</span> <span class="p">[[</span><span class="n">lk</span><span class="p">]</span> <span class="p">[</span><span class="n">rk</span><span class="p">]]</span> <span class="n">C</span>
@ -321,15 +322,15 @@ depositing our results directly on the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">i</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="n">swons</span> <span class="n">concat</span><span class="p">]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">treestep</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[]</span> <span class="p">[</span><span class="n">i</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="n">swons</span> <span class="n">concat</span><span class="p">]</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">treestep</span>
</pre></div> </pre></div>
</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;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [uncons pop] [i roll&lt; swons concat] treestep&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [uncons pop] [i roll&lt; swons concat] treestep&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span><span class="p">]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="with-treegrind"> <section id="with-treegrind">
<h2>With <code class="docutils literal notranslate"><span class="pre">treegrind</span></code>?<a class="headerlink" href="#with-treegrind" title="Permalink to this headline"></a></h2> <h2>With <code class="docutils literal notranslate"><span class="pre">treegrind</span></code>?<a class="headerlink" href="#with-treegrind" title="Permalink to this headline"></a></h2>
<p>The <code class="docutils literal notranslate"><span class="pre">treegrind</span></code> function doesn’t include the <code class="docutils literal notranslate"><span class="pre">map</span></code> combinator, so <p>The <code class="docutils literal notranslate"><span class="pre">treegrind</span></code> function doesn’t include the <code class="docutils literal notranslate"><span class="pre">map</span></code> combinator, so
the <code class="docutils literal notranslate"><span class="pre">[C]</span></code> function must arrange to use some combinator on the quoted the <code class="docutils literal notranslate"><span class="pre">[C]</span></code> function must arrange to use some combinator on the quoted
@ -342,38 +343,38 @@ non-empty node is:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">C</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">N</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">C</span>
</pre></div> </pre></div>
</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;[[&quot;key&quot; &quot;value&quot;] [&quot;left&quot;] [&quot;right&quot;] ] [&quot;B&quot;] [&quot;N&quot;] [&quot;C&quot;] treegrind&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[&quot;key&quot; &quot;value&quot;] [&quot;left&quot;] [&quot;right&quot;] ] [&quot;B&quot;] [&quot;N&quot;] [&quot;C&quot;] treegrind&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">&#39;key&#39;</span> <span class="s1">&#39;value&#39;</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[[</span><span class="s1">&#39;left&#39;</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">]]</span> <span class="p">[[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;B&#39;</span><span class="p">]</span> <span class="p">[</span><span class="n">uncons</span> <span class="p">[</span><span class="s1">&#39;N&#39;</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;C&#39;</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="s1">&#39;C&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">&#39;key&#39;</span> <span class="s1">&#39;value&#39;</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[[</span><span class="s1">&#39;left&#39;</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">]]</span> <span class="p">[[</span><span class="ow">not</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;B&#39;</span><span class="p">]</span> <span class="p">[</span><span class="n">uncons</span> <span class="p">[</span><span class="s1">&#39;N&#39;</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="p">[</span><span class="s1">&#39;C&#39;</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="s1">&#39;C&#39;</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="treegrind-with-step"> <section id="treegrind-with-step">
<h2><code class="docutils literal notranslate"><span class="pre">treegrind</span></code> with <code class="docutils literal notranslate"><span class="pre">step</span></code><a class="headerlink" href="#treegrind-with-step" title="Permalink to this headline"></a></h2> <h2><code class="docutils literal notranslate"><span class="pre">treegrind</span></code> with <code class="docutils literal notranslate"><span class="pre">step</span></code><a class="headerlink" href="#treegrind-with-step" title="Permalink to this headline"></a></h2>
<p>Iteration through the nodes</p> <p>Iteration through the nodes</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;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [pop] [&quot;N&quot;] [step] treegrind&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [pop] [&quot;N&quot;] [step] treegrind&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">9</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">5</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">8</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">6</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">7</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">9</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">5</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">8</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">6</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span> <span class="p">[</span><span class="mi">7</span> <span class="mi">0</span><span class="p">]</span> <span class="s1">&#39;N&#39;</span>
</pre></div> </pre></div>
</div> </div>
<p>Sum the nodes’ keys.</p> <p>Sum the nodes’ keys.</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;0 [[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [pop] [first +] [step] treegrind&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;0 [[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [pop] [first +] [step] treegrind&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">44</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">44</span>
</pre></div> </pre></div>
</div> </div>
<p>Rebuild the tree using <code class="docutils literal notranslate"><span class="pre">map</span></code> (imitating <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.)</p> <p>Rebuild the tree using <code class="docutils literal notranslate"><span class="pre">map</span></code> (imitating <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.)</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;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [[100 +] infra] [map cons] treegrind&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[[3 0] [[2 0] [] []] [[9 0] [[5 0] [[4 0] [] []] [[8 0] [[6 0] [] [[7 0] [] []]] []]] []]] [] [[100 +] infra] [map cons] treegrind&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="mi">103</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">102</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[[</span><span class="mi">109</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">105</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">104</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[[</span><span class="mi">108</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">106</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="mi">107</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]]</span> <span class="p">[]]]</span> <span class="p">[]]]</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="mi">103</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">102</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[[</span><span class="mi">109</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">105</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">104</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]</span> <span class="p">[[</span><span class="mi">108</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[[</span><span class="mi">106</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="mi">107</span> <span class="mi">0</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[]]]</span> <span class="p">[]]]</span> <span class="p">[]]]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="do-we-have-the-flexibility-to-reimplement-tree-get"> <section id="do-we-have-the-flexibility-to-reimplement-tree-get">
<h2>Do we have the flexibility to reimplement <code class="docutils literal notranslate"><span class="pre">Tree-get</span></code>?<a class="headerlink" href="#do-we-have-the-flexibility-to-reimplement-tree-get" title="Permalink to this headline"></a></h2> <h2>Do we have the flexibility to reimplement <code class="docutils literal notranslate"><span class="pre">Tree-get</span></code>?<a class="headerlink" href="#do-we-have-the-flexibility-to-reimplement-tree-get" title="Permalink to this headline"></a></h2>
<p>I think we do:</p> <p>I think we do:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="n">treegrind</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="n">treegrind</span>
@ -389,12 +390,12 @@ user defined, and the per-node function is just the query key literal:</p>
</pre></div> </pre></div>
</div> </div>
<p>Let’s try <code class="docutils literal notranslate"><span class="pre">cmp</span></code>:</p> <p>Let’s try <code class="docutils literal notranslate"><span class="pre">cmp</span></code>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">C</span> <span class="o">==</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="nb">cmp</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">C</span> <span class="o">==</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="n">cmp</span>
<span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">query_key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="nb">cmp</span> <span class="p">[</span><span class="n">key</span> <span class="n">value</span><span class="p">]</span> <span class="n">query_key</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="n">cmp</span>
</pre></div> </pre></div>
</div> </div>
<div class="section" id="the-predicate-p"> <section id="the-predicate-p">
<h3>The predicate <code class="docutils literal notranslate"><span class="pre">P</span></code><a class="headerlink" href="#the-predicate-p" title="Permalink to this headline"></a></h3> <h3>The predicate <code class="docutils literal notranslate"><span class="pre">P</span></code><a class="headerlink" href="#the-predicate-p" title="Permalink to this headline"></a></h3>
<p>Seems pretty easy (we must preserve the value in case the keys are <p>Seems pretty easy (we must preserve the value in case the keys are
equal):</p> equal):</p>
@ -412,7 +413,7 @@ equal):</p>
</div> </div>
<p>(Possibly with a swap at the end? Or just swap <code class="docutils literal notranslate"><span class="pre">T&lt;</span></code> and <code class="docutils literal notranslate"><span class="pre">T&gt;</span></code>.)</p> <p>(Possibly with a swap at the end? Or just swap <code class="docutils literal notranslate"><span class="pre">T&lt;</span></code> and <code class="docutils literal notranslate"><span class="pre">T&gt;</span></code>.)</p>
<p>So now:</p> <p>So now:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="n">key</span> <span class="n">query_key</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="nb">cmp</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="n">key</span> <span class="n">query_key</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="n">cmp</span>
</pre></div> </pre></div>
</div> </div>
<p>Becomes one of these three:</p> <p>Becomes one of these three:</p>
@ -421,105 +422,118 @@ equal):</p>
<span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="n">T</span><span class="o">&lt;</span> <span class="p">[</span><span class="n">left</span> <span class="n">right</span><span class="p">]</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="n">T</span><span class="o">&lt;</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="e"> <section id="e">
<h3><code class="docutils literal notranslate"><span class="pre">E</span></code><a class="headerlink" href="#e" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">E</span></code><a class="headerlink" href="#e" title="Permalink to this headline"></a></h3>
<p>Easy.</p> <p>Easy.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">E</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&gt;</span> <span class="n">popop</span> <span class="n">first</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">E</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&gt;</span> <span class="n">popop</span> <span class="n">first</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="t-and-t"> <section id="t-and-t">
<h3><code class="docutils literal notranslate"><span class="pre">T&lt;</span></code> and <code class="docutils literal notranslate"><span class="pre">T&gt;</span></code><a class="headerlink" href="#t-and-t" title="Permalink to this headline"></a></h3> <h3><code class="docutils literal notranslate"><span class="pre">T&lt;</span></code> and <code class="docutils literal notranslate"><span class="pre">T&gt;</span></code><a class="headerlink" href="#t-and-t" title="Permalink to this headline"></a></h3>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">&lt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">&lt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
<span class="n">T</span><span class="o">&gt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">second</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span> <span class="n">T</span><span class="o">&gt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">second</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
<div class="section" id="putting-it-together"> <section id="putting-it-together">
<h2>Putting it together<a class="headerlink" href="#putting-it-together" title="Permalink to this headline"></a></h2> <h2>Putting it together<a class="headerlink" href="#putting-it-together" title="Permalink to this headline"></a></h2>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">&gt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">T</span><span class="o">&gt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">first</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
<span class="n">T</span><span class="o">&lt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">second</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span> <span class="n">T</span><span class="o">&lt;</span> <span class="o">==</span> <span class="n">pop</span> <span class="p">[</span><span class="n">second</span><span class="p">]</span> <span class="n">dip</span> <span class="n">i</span>
<span class="n">E</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&gt;</span> <span class="n">popop</span> <span class="n">first</span> <span class="n">E</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&gt;</span> <span class="n">popop</span> <span class="n">first</span>
<span class="n">P</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="p">[</span><span class="n">roll</span><span class="o">&lt;</span> <span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="n">dip</span> <span class="n">P</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="p">[</span><span class="n">roll</span><span class="o">&lt;</span> <span class="n">uncons</span> <span class="n">swap</span><span class="p">]</span> <span class="n">dip</span>
<span class="n">Tree</span><span class="o">-</span><span class="n">get</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="nb">cmp</span><span class="p">]</span> <span class="n">treegrind</span> <span class="n">Tree</span><span class="o">-</span><span class="n">get</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span> <span class="p">[</span><span class="n">T</span><span class="o">&gt;</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="o">&lt;</span><span class="p">]</span> <span class="n">cmp</span><span class="p">]</span> <span class="n">treegrind</span>
</pre></div> </pre></div>
</div> </div>
<p>To me, that seems simpler than the <code class="docutils literal notranslate"><span class="pre">genrec</span></code> version.</p> <p>To me, that seems simpler than the <code class="docutils literal notranslate"><span class="pre">genrec</span></code> version.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>DefinitionWrapper.add_definitions(&#39;&#39;&#39;
<span class="s1"> T&gt; == pop [first] dip i</span> T&gt; == pop [first] dip i
<span class="s1"> T&lt; == pop [second] dip i</span> T&lt; == pop [second] dip i
<span class="s1"> E == roll&gt; popop first</span> E == roll&gt; popop first
<span class="s1"> P == roll&lt; [roll&lt; uncons swap] dip</span> P == roll&lt; [roll&lt; uncons swap] dip
<span class="s1"> Tree-get == [P [T&gt;] [E] [T&lt;] cmp] treegrind</span> Tree-get == [P [T&gt;] [E] [T&lt;] cmp] treegrind
<span class="s1">&#39;&#39;&#39;</span><span class="p">,</span> <span class="n">D</span><span class="p">)</span> &#39;&#39;&#39;, D)
</pre></div> </pre></div>
</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;&#39;&#39;</span><span class="se">\</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;&#39;&#39;\
<span class="s1">[[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]</span> [[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]
<span class="s1">[] [5] Tree-get</span> [] [5] Tree-get
<span class="s1">&#39;&#39;&#39;</span><span class="p">)</span> &#39;&#39;&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">15</span>
</pre></div> </pre></div>
</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;&#39;&#39;</span><span class="se">\</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;&#39;&#39;\
<span class="s1">[[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]</span> [[3 13] [[2 12] [] []] [[9 19] [[5 15] [[4 14] [] []] [[8 18] [[6 16] [] [[7 17] [] []]] []]] []]]
<span class="s1">[pop &quot;nope&quot;] [25] Tree-get</span> [pop &quot;nope&quot;] [25] Tree-get
<span class="s1">&#39;&#39;&#39;</span><span class="p">)</span> &#39;&#39;&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">&#39;nope&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">&#39;nope&#39;</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a><ul>
<li><a class="reference internal" href="#derive-the-recursive-function">Derive the recursive function.</a></li>
<li><a class="reference internal" href="#extract-the-givens-to-parameterize-the-program">Extract the givens to parameterize the program.</a><ul>
<li><a class="reference internal" href="#alternate-extract-the-givens-to-parameterize-the-program">(alternate) Extract the givens to parameterize the program.</a></li>
</ul>
</li>
<li><a class="reference internal" href="#define-treestep">Define <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li><a class="reference internal" href="#examples">Examples</a></li> <h3>Navigation</h3>
<li><a class="reference internal" href="#redefining-the-ordered-binary-tree-in-terms-of-treestep">Redefining the Ordered Binary Tree in terms of <code class="docutils literal notranslate"><span class="pre">treestep</span></code>.</a><ul> <ul class="current">
<li><a class="reference internal" href="#traversal">Traversal</a></li> <li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li><a class="reference internal" href="#in-order-traversal">In-order traversal</a></li> <li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
</ul> <li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
</li> <li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li><a class="reference internal" href="#with-treegrind">With <code class="docutils literal notranslate"><span class="pre">treegrind</span></code>?</a></li> <li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li><a class="reference internal" href="#treegrind-with-step"><code class="docutils literal notranslate"><span class="pre">treegrind</span></code> with <code class="docutils literal notranslate"><span class="pre">step</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li><a class="reference internal" href="#do-we-have-the-flexibility-to-reimplement-tree-get">Do we have the flexibility to reimplement <code class="docutils literal notranslate"><span class="pre">Tree-get</span></code>?</a><ul> <li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li><a class="reference internal" href="#the-predicate-p">The predicate <code class="docutils literal notranslate"><span class="pre">P</span></code></a></li> <li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li><a class="reference internal" href="#e"><code class="docutils literal notranslate"><span class="pre">E</span></code></a></li> <li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li><a class="reference internal" href="#t-and-t"><code class="docutils literal notranslate"><span class="pre">T&lt;</span></code> and <code class="docutils literal notranslate"><span class="pre">T&gt;</span></code></a></li> <li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
</ul> <li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
</li> <li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li><a class="reference internal" href="#putting-it-together">Putting it together</a></li> <li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -531,25 +545,24 @@ equal):</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Treestep.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -560,7 +573,7 @@ equal):</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

187
docs/sphinx_docs/_build/html/notebooks/TypeChecking.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Type Checking &#8212; Thun 0.4.1 documentation</title> <title>Type Checking &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="No Updates" href="NoUpdates.html" /> <link rel="next" title="No Updates" href="NoUpdates.html" />
@ -30,37 +29,39 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="type-checking"> <section id="type-checking">
<h1>Type Checking<a class="headerlink" href="#type-checking" title="Permalink to this headline"></a></h1> <h1>Type Checking<a class="headerlink" href="#type-checking" title="Permalink to this headline"></a></h1>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">logging</span><span class="o">,</span> <span class="nn">sys</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>import logging, sys
<span class="n">logging</span><span class="o">.</span><span class="n">basicConfig</span><span class="p">(</span> logging.basicConfig(
<span class="nb">format</span><span class="o">=</span><span class="s1">&#39;</span><span class="si">%(message)s</span><span class="s1">&#39;</span><span class="p">,</span> format=&#39;%(message)s&#39;,
<span class="n">stream</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="p">,</span> stream=sys.stdout,
<span class="n">level</span><span class="o">=</span><span class="n">logging</span><span class="o">.</span><span class="n">INFO</span><span class="p">,</span> level=logging.INFO,
<span class="p">)</span> )
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.utils.types</span> <span class="k">import</span> <span class="p">(</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from joy.utils.types import (
<span class="n">doc_from_stack_effect</span><span class="p">,</span> doc_from_stack_effect,
<span class="n">infer</span><span class="p">,</span> infer,
<span class="n">reify</span><span class="p">,</span> reify,
<span class="n">unify</span><span class="p">,</span> unify,
<span class="n">FUNCTIONS</span><span class="p">,</span> FUNCTIONS,
<span class="n">JoyTypeError</span><span class="p">,</span> JoyTypeError,
<span class="p">)</span> )
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">D</span> <span class="o">=</span> <span class="n">FUNCTIONS</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>D = FUNCTIONS.copy()
<span class="k">del</span> <span class="n">D</span><span class="p">[</span><span class="s1">&#39;product&#39;</span><span class="p">]</span> del D[&#39;product&#39;]
<span class="nb">globals</span><span class="p">()</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">D</span><span class="p">)</span> globals().update(D)
</pre></div> </pre></div>
</div> </div>
<div class="section" id="an-example"> <section id="an-example">
<h2>An Example<a class="headerlink" href="#an-example" title="Permalink to this headline"></a></h2> <h2>An Example<a class="headerlink" href="#an-example" title="Permalink to this headline"></a></h2>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rrest</span><span class="p">,</span> <span class="n">ccons</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>fi, fo = infer(pop, swap, rolldown, rrest, ccons)[0]
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>25 (--) ∘ pop swap rolldown rrest ccons <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>25 (--) ∘ pop swap rolldown rrest ccons
@ -71,61 +72,61 @@
40 ([a4 a5 ...1] a3 a2 a1 -- [a2 a3 ...1]) ∘ 40 ([a4 a5 ...1] a3 a2 a1 -- [a2 a3 ...1]) ∘
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print doc_from_stack_effect(fi, fo)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from joy.parser import text_to_expression
<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="k">import</span> <span class="n">stack_to_string</span> from joy.utils.stack import stack_to_string
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">e</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;0 1 2 [3 4]&#39;</span><span class="p">)</span> <span class="c1"># reverse order</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>e = text_to_expression(&#39;0 1 2 [3 4]&#39;) # reverse order
<span class="nb">print</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">e</span><span class="p">)</span> print stack_to_string(e)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">u</span> <span class="o">=</span> <span class="n">unify</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">fi</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>u = unify(e, fi)[0]
<span class="n">u</span> u
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{</span><span class="n">a1</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="n">a2</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="n">a3</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="n">a4</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="n">a5</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="n">s2</span><span class="p">:</span> <span class="p">(),</span> <span class="n">s1</span><span class="p">:</span> <span class="p">()}</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{</span><span class="n">a1</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="n">a2</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="n">a3</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="n">a4</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="n">a5</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="n">s2</span><span class="p">:</span> <span class="p">(),</span> <span class="n">s1</span><span class="p">:</span> <span class="p">()}</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">g</span> <span class="o">=</span> <span class="n">reify</span><span class="p">(</span><span class="n">u</span><span class="p">,</span> <span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">))</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>g = reify(u, (fi, fo))
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">g</span><span class="p">)</span> print doc_from_stack_effect(*g)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">...</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="p">]</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span> <span class="o">--</span> <span class="o">...</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="p">])</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">...</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="p">]</span> <span class="mi">2</span> <span class="mi">1</span> <span class="mi">0</span> <span class="o">--</span> <span class="o">...</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="p">])</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="unification-works-in-reverse"> <section id="unification-works-in-reverse">
<h2>Unification Works “in Reverse”<a class="headerlink" href="#unification-works-in-reverse" title="Permalink to this headline"></a></h2> <h2>Unification Works “in Reverse”<a class="headerlink" href="#unification-works-in-reverse" title="Permalink to this headline"></a></h2>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">e</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[2 3]&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>e = text_to_expression(&#39;[2 3]&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">u</span> <span class="o">=</span> <span class="n">unify</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">fo</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span> <span class="c1"># output side, not input side</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>u = unify(e, fo)[0] # output side, not input side
<span class="n">u</span> u
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{</span><span class="n">a2</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="n">a3</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="n">s2</span><span class="p">:</span> <span class="p">(),</span> <span class="n">s1</span><span class="p">:</span> <span class="p">()}</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{</span><span class="n">a2</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="n">a3</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="n">s2</span><span class="p">:</span> <span class="p">(),</span> <span class="n">s1</span><span class="p">:</span> <span class="p">()}</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">g</span> <span class="o">=</span> <span class="n">reify</span><span class="p">(</span><span class="n">u</span><span class="p">,</span> <span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">))</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>g = reify(u, (fi, fo))
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">g</span><span class="p">)</span> print doc_from_stack_effect(*g)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">...</span> <span class="p">[</span><span class="n">a4</span> <span class="n">a5</span> <span class="p">]</span> <span class="mi">3</span> <span class="mi">2</span> <span class="n">a1</span> <span class="o">--</span> <span class="o">...</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="p">])</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">...</span> <span class="p">[</span><span class="n">a4</span> <span class="n">a5</span> <span class="p">]</span> <span class="mi">3</span> <span class="mi">2</span> <span class="n">a1</span> <span class="o">--</span> <span class="o">...</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="p">])</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="failing-a-check"> <section id="failing-a-check">
<h2>Failing a Check<a class="headerlink" href="#failing-a-check" title="Permalink to this headline"></a></h2> <h2>Failing a Check<a class="headerlink" href="#failing-a-check" title="Permalink to this headline"></a></h2>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">dup</span><span class="p">,</span> <span class="n">mul</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>fi, fo = infer(dup, mul)[0]
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>25 (--) ∘ dup mul <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>25 (--) ∘ dup mul
@ -134,40 +135,71 @@
31 (i1 -- i2) ∘ 31 (i1 -- i2) ∘
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">e</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;&quot;two&quot;&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>e = text_to_expression(&#39;&quot;two&quot;&#39;)
<span class="nb">print</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">e</span><span class="p">)</span> print stack_to_string(e)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">&#39;two&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="s1">&#39;two&#39;</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">try</span><span class="p">:</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>try:
<span class="n">unify</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">fi</span><span class="p">)</span> unify(e, fi)
<span class="k">except</span> <span class="n">JoyTypeError</span><span class="p">,</span> <span class="n">err</span><span class="p">:</span> except JoyTypeError, err:
<span class="nb">print</span> <span class="n">err</span> print err
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Cannot</span> <span class="n">unify</span> <span class="s1">&#39;two&#39;</span> <span class="ow">and</span> <span class="n">f1</span><span class="o">.</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Cannot</span> <span class="n">unify</span> <span class="s1">&#39;two&#39;</span> <span class="ow">and</span> <span class="n">f1</span><span class="o">.</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Type Checking</a><ul>
<li><a class="reference internal" href="#an-example">An Example</a></li>
<li><a class="reference internal" href="#unification-works-in-reverse">Unification Works “in Reverse”</a></li>
<li><a class="reference internal" href="#failing-a-check">Failing a Check</a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -179,25 +211,24 @@
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/TypeChecking.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -208,7 +239,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

1804
docs/sphinx_docs/_build/html/notebooks/Types.html
View File

File diff suppressed because it is too large Load Diff

166
docs/sphinx_docs/_build/html/notebooks/Zipper.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Traversing Datastructures with Zippers &#8212; Thun 0.4.1 documentation</title> <title>Traversing Datastructures with Zippers &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="The Blissful Elegance of Typing Joy" href="Types.html" /> <link rel="next" title="The Blissful Elegance of Typing Joy" href="Types.html" />
@ -30,9 +29,11 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="traversing-datastructures-with-zippers"> <section id="traversing-datastructures-with-zippers">
<h1>Traversing Datastructures with Zippers<a class="headerlink" href="#traversing-datastructures-with-zippers" title="Permalink to this headline"></a></h1> <h1>Traversing Datastructures with Zippers<a class="headerlink" href="#traversing-datastructures-with-zippers" title="Permalink to this headline"></a></h1>
<p>This notebook is about using the “zipper” with joy datastructures. See <p>This notebook is about using the “zipper” with joy datastructures. See
the <a class="reference external" href="https://en.wikipedia.org/wiki/Zipper_%28data_structure%29">Zipper wikipedia the <a class="reference external" href="https://en.wikipedia.org/wiki/Zipper_%28data_structure%29">Zipper wikipedia
@ -41,24 +42,24 @@ the original paper: <a class="reference external" href="https://www.st.cs.uni-sa
Huet</a></p> Huet</a></p>
<p>Given a datastructure on the stack we can navigate through it, modify <p>Given a datastructure on the stack we can navigate through it, modify
it, and rebuild it using the “zipper” technique.</p> it, and rebuild it using the “zipper” technique.</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="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from notebook_preamble import J, V, define
</pre></div> </pre></div>
</div> </div>
<div class="section" id="trees"> <section id="trees">
<h2>Trees<a class="headerlink" href="#trees" title="Permalink to this headline"></a></h2> <h2>Trees<a class="headerlink" href="#trees" title="Permalink to this headline"></a></h2>
<p>In Joypy there aren’t any complex datastructures, just ints, floats, <p>In Joypy there aren’t any complex datastructures, just ints, floats,
strings, Symbols (strings that are names of functions) and sequences strings, Symbols (strings that are names of functions) and sequences
(aka lists, aka quoted literals, aka aggregates, etc…), but we can build (aka lists, aka quoted literals, aka aggregates, etc…), but we can build
<a class="reference external" href="https://en.wikipedia.org/wiki/Tree_%28data_structure%29">trees</a> out <a class="reference external" href="https://en.wikipedia.org/wiki/Tree_%28data_structure%29">trees</a> out
of sequences.</p> of sequences.</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;[1 [2 [3 4 25 6] 7] 8]&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1 [2 [3 4 25 6] 7] 8]&#39;)
</pre></div> </pre></div>
</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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="zipper-in-joy"> <section id="zipper-in-joy">
<h2>Zipper in Joy<a class="headerlink" href="#zipper-in-joy" title="Permalink to this headline"></a></h2> <h2>Zipper in Joy<a class="headerlink" href="#zipper-in-joy" title="Permalink to this headline"></a></h2>
<p>Zippers work by keeping track of the current item, the already-seen <p>Zippers work by keeping track of the current item, the already-seen
items, and the yet-to-be seen items as you traverse a datastructure (the items, and the yet-to-be seen items as you traverse a datastructure (the
@ -74,13 +75,13 @@ datastructure used to keep track of these items is the zipper.)</p>
show the trace so you can see how it works. If we were going to use show the trace so you can see how it works. If we were going to use
these a lot it would make sense to write Python versions for efficiency, these a lot it would make sense to write Python versions for efficiency,
but see below.</p> but see below.</p>
<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;z-down == [] swap uncons swap&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;z-down == [] swap uncons swap&#39;)
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;z-up == swons swap shunt&#39;</span><span class="p">)</span> define(&#39;z-up == swons swap shunt&#39;)
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;z-right == [swons] cons dip uncons swap&#39;</span><span class="p">)</span> define(&#39;z-right == [swons] cons dip uncons swap&#39;)
<span class="n">define</span><span class="p">(</span><span class="s1">&#39;z-left == swons [uncons swap] dip swap&#39;</span><span class="p">)</span> define(&#39;z-left == swons [uncons swap] dip swap&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[1 [2 [3 4 25 6] 7] 8] z-down&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[1 [2 [3 4 25 6] 7] 8] z-down&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="n">z</span><span class="o">-</span><span class="n">down</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="n">z</span><span class="o">-</span><span class="n">down</span>
@ -92,7 +93,7 @@ but see below.</p>
<span class="p">[]</span> <span class="p">[[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="mi">1</span> <span class="o">.</span> <span class="p">[]</span> <span class="p">[[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="mi">1</span> <span class="o">.</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[] [[2 [3 4 25 6] 7] 8] 1 z-right&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[] [[2 [3 4 25 6] 7] 8] 1 z-right&#39;)
</pre></div> </pre></div>
</div> </div>
<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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="mi">1</span> <span class="n">z</span><span class="o">-</span><span class="n">right</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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="mi">1</span> <span class="n">z</span><span class="o">-</span><span class="n">right</span>
@ -112,43 +113,43 @@ but see below.</p>
<span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="o">.</span>
</pre></div> </pre></div>
</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;[1] [8] [2 [3 4 25 6] 7] z-down&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2 [3 4 25 6] 7] z-down&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">2</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">2</span>
</pre></div> </pre></div>
</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;[1] [8] [] [[3 4 25 6] 7] 2 z-right&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [] [[3 4 25 6] 7] 2 z-right&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span>
</pre></div> </pre></div>
</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;[1] [8] [2] [7] [3 4 25 6] z-down&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2] [7] [3 4 25 6] z-down&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">3</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">3</span>
</pre></div> </pre></div>
</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;[1] [8] [2] [7] [] [4 25 6] 3 z-right&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2] [7] [] [4 25 6] 3 z-right&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">4</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">4</span>
</pre></div> </pre></div>
</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;[1] [8] [2] [7] [3] [25 6] 4 z-right&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2] [7] [3] [25 6] 4 z-right&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">25</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">25</span>
</pre></div> </pre></div>
</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;[1] [8] [2] [7] [4 3] [6] 25 sqr&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2] [7] [4 3] [6] 25 sqr&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">625</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">625</span>
</pre></div> </pre></div>
</div> </div>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[1] [8] [2] [7] [4 3] [6] 625 z-up&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[1] [8] [2] [7] [4 3] [6] 625 z-up&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">625</span> <span class="n">z</span><span class="o">-</span><span class="n">up</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">4</span> <span class="mi">3</span><span class="p">]</span> <span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="mi">625</span> <span class="n">z</span><span class="o">-</span><span class="n">up</span>
@ -167,24 +168,24 @@ but see below.</p>
<span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">[</span><span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="o">.</span>
</pre></div> </pre></div>
</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;[1] [8] [2] [7] [3 4 625 6] z-up&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2] [7] [3 4 625 6] z-up&#39;)
</pre></div> </pre></div>
</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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <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="p">[</span><span class="mi">8</span><span class="p">]</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span>
</pre></div> </pre></div>
</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;[1] [8] [2 [3 4 625 6] 7] z-up&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1] [8] [2 [3 4 625 6] 7] z-up&#39;)
</pre></div> </pre></div>
</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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="dip-and-infra"> <section id="dip-and-infra">
<h2><code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">infra</span></code><a class="headerlink" href="#dip-and-infra" title="Permalink to this headline"></a></h2> <h2><code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">infra</span></code><a class="headerlink" href="#dip-and-infra" title="Permalink to this headline"></a></h2>
<p>In Joy we have the <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">infra</span></code> combinators which can “target” <p>In Joy we have the <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">infra</span></code> combinators which can “target”
or “address” any particular item in a Joy tree structure.</p> or “address” any particular item in a Joy tree structure.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;[1 [2 [3 4 25 6] 7] 8] [[[[[[sqr] dipd] infra] dip] infra] dip] infra&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;[1 [2 [3 4 25 6] 7] 8] [[[[[[sqr] dipd] infra] dip] infra] dip] infra&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="p">[</span><span class="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="p">[[[[[[</span><span class="n">sqr</span><span class="p">]</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">infra</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">infra</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</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="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">25</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <span class="p">[[[[[[</span><span class="n">sqr</span><span class="p">]</span> <span class="n">dipd</span><span class="p">]</span> <span class="n">infra</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">infra</span><span class="p">]</span> <span class="n">dip</span><span class="p">]</span> <span class="n">infra</span>
@ -222,8 +223,8 @@ the subject datastructure. Instead of maintaining temporary results on
the stack they are pushed into the pending expression (continuation). the stack they are pushed into the pending expression (continuation).
When <code class="docutils literal notranslate"><span class="pre">sqr</span></code> has run the rest of the pending expression rebuilds the When <code class="docutils literal notranslate"><span class="pre">sqr</span></code> has run the rest of the pending expression rebuilds the
datastructure.</p> datastructure.</p>
</div> </section>
<div class="section" id="z"> <section id="z">
<h2><code class="docutils literal notranslate"><span class="pre">Z</span></code><a class="headerlink" href="#z" title="Permalink to this headline"></a></h2> <h2><code class="docutils literal notranslate"><span class="pre">Z</span></code><a class="headerlink" href="#z" title="Permalink to this headline"></a></h2>
<p>Imagine a function <code class="docutils literal notranslate"><span class="pre">Z</span></code> that accepts a sequence of <code class="docutils literal notranslate"><span class="pre">dip</span></code> and <p>Imagine a function <code class="docutils literal notranslate"><span class="pre">Z</span></code> that accepts a sequence of <code class="docutils literal notranslate"><span class="pre">dip</span></code> and
<code class="docutils literal notranslate"><span class="pre">infra</span></code> combinators, a quoted program <code class="docutils literal notranslate"><span class="pre">[Q]</span></code>, and a datastructure to <code class="docutils literal notranslate"><span class="pre">infra</span></code> combinators, a quoted program <code class="docutils literal notranslate"><span class="pre">[Q]</span></code>, and a datastructure to
@ -235,11 +236,11 @@ been embedded in a nested series of quoted programs, e.g.:</p>
</pre></div> </pre></div>
</div> </div>
<p>The <code class="docutils literal notranslate"><span class="pre">Z</span></code> function isn’t hard to make.</p> <p>The <code class="docutils literal notranslate"><span class="pre">Z</span></code> function isn’t hard to make.</p>
<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;Z == [[] cons cons] step i&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>define(&#39;Z == [[] cons cons] step i&#39;)
</pre></div> </pre></div>
</div> </div>
<p>Here it is in action in a simplified scenario.</p> <p>Here it is in action in a simplified scenario.</p>
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">&#39;1 [2 3 4] Z&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>V(&#39;1 [2 3 4] Z&#39;)
</pre></div> </pre></div>
</div> </div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <span class="n">Z</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">.</span> <span class="mi">1</span> <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <span class="n">Z</span>
@ -272,14 +273,14 @@ been embedded in a nested series of quoted programs, e.g.:</p>
</pre></div> </pre></div>
</div> </div>
<p>And here it is doing the main thing.</p> <p>And here it is doing the main thing.</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;[1 [2 [3 4 25 6] 7] 8] [sqr] [dip dip infra dip infra dip infra] Z&#39;</span><span class="p">)</span> <div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>J(&#39;[1 [2 [3 4 25 6] 7] 8] [sqr] [dip dip infra dip infra dip infra] Z&#39;)
</pre></div> </pre></div>
</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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span> <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="mi">2</span> <span class="p">[</span><span class="mi">3</span> <span class="mi">4</span> <span class="mi">625</span> <span class="mi">6</span><span class="p">]</span> <span class="mi">7</span><span class="p">]</span> <span class="mi">8</span><span class="p">]</span>
</pre></div> </pre></div>
</div> </div>
</div> </section>
<div class="section" id="addressing"> <section id="addressing">
<h2>Addressing<a class="headerlink" href="#addressing" title="Permalink to this headline"></a></h2> <h2>Addressing<a class="headerlink" href="#addressing" title="Permalink to this headline"></a></h2>
<p>Because we are only using two combinators we could replace the list with <p>Because we are only using two combinators we could replace the list with
a string made from only two characters.</p> a string made from only two characters.</p>
@ -290,8 +291,8 @@ a string made from only two characters.</p>
</div> </div>
<p>The string can be considered a name or address for an item in the <p>The string can be considered a name or address for an item in the
subject datastructure.</p> subject datastructure.</p>
</div> </section>
<div class="section" id="determining-the-right-path-for-an-item-in-a-tree"> <section id="determining-the-right-path-for-an-item-in-a-tree">
<h2>Determining the right “path” for an item in a tree.<a class="headerlink" href="#determining-the-right-path-for-an-item-in-a-tree" title="Permalink to this headline"></a></h2> <h2>Determining the right “path” for an item in a tree.<a class="headerlink" href="#determining-the-right-path-for-an-item-in-a-tree" title="Permalink to this headline"></a></h2>
<p>It’s easy to read off (in reverse) the right sequence of “d” and “i” <p>It’s easy to read off (in reverse) the right sequence of “d” and “i”
from the subject datastructure:</p> from the subject datastructure:</p>
@ -299,27 +300,55 @@ from the subject datastructure:</p>
i d i d i d d Bingo! i d i d i d d Bingo!
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="../index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Traversing Datastructures with Zippers</a><ul>
<li><a class="reference internal" href="#trees">Trees</a></li>
<li><a class="reference internal" href="#zipper-in-joy">Zipper in Joy</a></li>
<li><a class="reference internal" href="#dip-and-infra"><code class="docutils literal notranslate"><span class="pre">dip</span></code> and <code class="docutils literal notranslate"><span class="pre">infra</span></code></a></li>
<li><a class="reference internal" href="#z"><code class="docutils literal notranslate"><span class="pre">Z</span></code></a></li>
<li><a class="reference internal" href="#addressing">Addressing</a></li>
<li><a class="reference internal" href="#determining-the-right-path-for-an-item-in-a-tree">Determining the right “path” for an item in a tree.</a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Essays about Programming in Joy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul> </ul>
</li> </li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -331,25 +360,24 @@ i d i d i d d Bingo!
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/Zipper.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -360,7 +388,7 @@ i d i d i d d Bingo!
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

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

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Essays about Programming in Joy &#8212; Thun 0.4.1 documentation</title> <title>Essays about Programming in Joy &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script type="text/javascript" src="../_static/documentation_options.js"></script> <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script> <script src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script> <script src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script> <script src="../_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" /> <link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" /> <link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Developing a Program in Joy" href="Developing.html" /> <link rel="next" title="Developing a Program in Joy" href="Developing.html" />
@ -30,9 +29,11 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="essays-about-programming-in-joy"> <section id="essays-about-programming-in-joy">
<h1>Essays about Programming in Joy<a class="headerlink" href="#essays-about-programming-in-joy" title="Permalink to this headline"></a></h1> <h1>Essays about Programming in Joy<a class="headerlink" href="#essays-about-programming-in-joy" title="Permalink to this headline"></a></h1>
<p>These essays are adapted from Jupyter notebooks. I hope to have those hosted somewhere where people can view them “live” and interact with them, possibly on MS Azure. For now, Sphinx does such a great job rendering the HTML that I am copying over some notebooks in ReST format and hand-editing them into these documents.</p> <p>These essays are adapted from Jupyter notebooks. I hope to have those hosted somewhere where people can view them “live” and interact with them, possibly on MS Azure. For now, Sphinx does such a great job rendering the HTML that I am copying over some notebooks in ReST format and hand-editing them into these documents.</p>
<div class="toctree-wrapper compound"> <div class="toctree-wrapper compound">
@ -156,14 +157,55 @@
</li> </li>
</ul> </ul>
</div> </div>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Essays about Programming in Joy</a><ul>
<li class="toctree-l2"><a class="reference internal" href="Developing.html">Developing a Program in Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="Recursion_Combinators.html">Recursion Combinators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator_Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="Zipper.html">Traversing Datastructures with Zippers</a></li>
<li class="toctree-l2"><a class="reference internal" href="Types.html">The Blissful Elegance of Typing Joy</a></li>
<li class="toctree-l2"><a class="reference internal" href="TypeChecking.html">Type Checking</a></li>
<li class="toctree-l2"><a class="reference internal" href="NoUpdates.html">No Updates</a></li>
<li class="toctree-l2"><a class="reference internal" href="Categorical.html">Categorical Programming</a></li>
<li class="toctree-l2"><a class="reference internal" href="The_Four_Operations.html">The Four Fundamental Operations of Definite Action</a></li>
<li class="toctree-l2"><a class="reference internal" href="Derivatives_of_Regular_Expressions.html">∂RE</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="../index.html">Documentation overview</a><ul> <li><a href="../index.html">Documentation overview</a><ul>
@ -172,25 +214,24 @@
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/notebooks/index.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="../search.html" method="get"> <form class="search" action="../search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -201,7 +242,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

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

Binary file not shown.

132
docs/sphinx_docs/_build/html/parser.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Parsing Text into Joy Expressions &#8212; Thun 0.4.1 documentation</title> <title>Parsing Text into Joy Expressions &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Tracing Joy Execution" href="pretty.html" /> <link rel="next" title="Tracing Joy Execution" href="pretty.html" />
@ -30,12 +29,14 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="parsing-text-into-joy-expressions"> <section id="parsing-text-into-joy-expressions">
<h1>Parsing Text into Joy Expressions<a class="headerlink" href="#parsing-text-into-joy-expressions" title="Permalink to this headline"></a></h1> <h1>Parsing Text into Joy Expressions<a class="headerlink" href="#parsing-text-into-joy-expressions" title="Permalink to this headline"></a></h1>
<p>TODO: example…</p> <p>TODO: example…</p>
<div class="section" id="module-joy.parser"> <section id="module-joy.parser">
<span id="joy-parser"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.parser</span></code><a class="headerlink" href="#module-joy.parser" title="Permalink to this headline"></a></h2> <span id="joy-parser"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.parser</span></code><a class="headerlink" href="#module-joy.parser" title="Permalink to this headline"></a></h2>
<p>This module exports a single function for converting text to a joy <p>This module exports a single function for converting text to a joy
expression as well as a single Symbol class and a single Exception type.</p> expression as well as a single Symbol class and a single Exception type.</p>
@ -51,60 +52,78 @@ literal value (integer, float, string, or Joy expression) or a function
symbol. Function symbols are unquoted strings and cannot contain square symbol. Function symbols are unquoted strings 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="exception"> <dl class="py exception">
<dt id="joy.parser.ParseError"> <dt class="sig sig-object py" id="joy.parser.ParseError">
<em class="property">exception </em><code class="descclassname">joy.parser.</code><code class="descname">ParseError</code><a class="reference internal" href="_modules/joy/parser.html#ParseError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.parser.ParseError" title="Permalink to this definition"></a></dt> <em class="property"><span class="pre">exception</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">joy.parser.</span></span><span class="sig-name descname"><span class="pre">ParseError</span></span><a class="reference internal" href="_modules/joy/parser.html#ParseError"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.parser.ParseError" title="Permalink to this definition"></a></dt>
<dd><p>Raised when there is a error while parsing text.</p> <dd><p>Raised when there is a error while parsing text.</p>
</dd></dl> </dd></dl>
<dl class="class"> <dl class="py class">
<dt id="joy.parser.Symbol"> <dt class="sig sig-object py" id="joy.parser.Symbol">
<em class="property">class </em><code class="descclassname">joy.parser.</code><code class="descname">Symbol</code><a class="reference internal" href="_modules/joy/parser.html#Symbol"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.parser.Symbol" title="Permalink to this definition"></a></dt> <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">joy.parser.</span></span><span class="sig-name descname"><span class="pre">Symbol</span></span><a class="reference internal" href="_modules/joy/parser.html#Symbol"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.parser.Symbol" title="Permalink to this definition"></a></dt>
<dd><p>A string class that represents Joy function names.</p> <dd><p>A string class that represents Joy function names.</p>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.parser.text_to_expression"> <dt class="sig sig-object py" id="joy.parser.text_to_expression">
<code class="descclassname">joy.parser.</code><code class="descname">text_to_expression</code><span class="sig-paren">(</span><em>text</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/parser.html#text_to_expression"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.parser.text_to_expression" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.parser.</span></span><span class="sig-name descname"><span class="pre">text_to_expression</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">text</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/parser.html#text_to_expression"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.parser.text_to_expression" title="Permalink to this definition"></a></dt>
<dd><p>Convert a string to a Joy expression.</p> <dd><p>Convert a string to a Joy expression.</p>
<p>When supplied with a string this function returns a Python datastructure <p>When supplied with a string this function returns a Python datastructure
that represents the Joy datastructure described by the text expression. that represents the Joy datastructure described by the text expression.
Any unbalanced square brackets will raise a ParseError.</p> Any unbalanced square brackets will raise a ParseError.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><p><strong>text</strong> (<em>str</em>) – Text to convert.</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>text</strong> (<em>str</em>) – Text to convert.</td> <dt class="field-even">Return type</dt>
</tr> <dd class="field-even"><p>stack</p>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body">stack</td> </dd>
</tr> <dt class="field-odd">Raises</dt>
<tr class="field-odd field"><th class="field-name">Raises:</th><td class="field-body"><a class="reference internal" href="#joy.parser.ParseError" title="joy.parser.ParseError"><strong>ParseError</strong></a> – if the parse fails.</td> <dd class="field-odd"><p><a class="reference internal" href="#joy.parser.ParseError" title="joy.parser.ParseError"><strong>ParseError</strong></a> – if the parse fails.</p>
</tr> </dd>
</tbody> </dl>
</table>
</dd></dl> </dd></dl>
</div> </section>
<div class="section" id="parser-internals"> <section id="parser-internals">
<h2>Parser Internals<a class="headerlink" href="#parser-internals" title="Permalink to this headline"></a></h2> <h2>Parser Internals<a class="headerlink" href="#parser-internals" title="Permalink to this headline"></a></h2>
<p>TODO: Document things like the regular expressions used for tokenizing, and the re.Scanner, etc…</p> <p>TODO: Document things like the regular expressions used for tokenizing, and the re.Scanner, etc…</p>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Parsing Text into Joy Expressions</a><ul>
<li><a class="reference internal" href="#module-joy.parser"><code class="docutils literal notranslate"><span class="pre">joy.parser</span></code></a></li>
<li><a class="reference internal" href="#parser-internals">Parser Internals</a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Parsing Text into Joy Expressions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#module-joy.parser"><code class="docutils literal notranslate"><span class="pre">joy.parser</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#parser-internals">Parser Internals</a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -114,25 +133,24 @@ Any unbalanced square brackets will raise a ParseError.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/parser.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -143,7 +161,7 @@ Any unbalanced square brackets will raise a ParseError.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

166
docs/sphinx_docs/_build/html/pretty.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Tracing Joy Execution &#8212; Thun 0.4.1 documentation</title> <title>Tracing Joy Execution &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Function Reference" href="library.html" /> <link rel="next" title="Function Reference" href="library.html" />
@ -30,11 +29,13 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="tracing-joy-execution"> <section id="tracing-joy-execution">
<h1>Tracing Joy Execution<a class="headerlink" href="#tracing-joy-execution" title="Permalink to this headline"></a></h1> <h1>Tracing Joy Execution<a class="headerlink" href="#tracing-joy-execution" title="Permalink to this headline"></a></h1>
<div class="section" id="module-joy.utils.pretty_print"> <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> <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> <p>Pretty printing support, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Joy? [23 18 * 99 +] trace <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Joy? [23 18 * 99 +] trace
@ -53,89 +54,97 @@ joy?
<p>On each line the stack is printed with the top to the left, then a <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 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> the pending expression to the right.</p>
<dl class="class"> <dl class="py class">
<dt id="joy.utils.pretty_print.TracePrinter"> <dt class="sig sig-object py" 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> <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">joy.utils.pretty_print.</span></span><span class="sig-name descname"><span class="pre">TracePrinter</span></span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter" title="Permalink to this definition"></a></dt>
<dd><p>This is what does the formatting. You instantiate it and pass the <code class="docutils literal notranslate"><span class="pre">viewer()</span></code> <dd><p>This is what does the formatting. You instantiate it and pass the <code class="docutils literal notranslate"><span class="pre">viewer()</span></code>
method to the <a class="reference internal" href="joy.html#joy.joy.joy" title="joy.joy.joy"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.joy.joy()</span></code></a> function, then print it to see the method to the <a class="reference internal" href="joy.html#joy.joy.joy" title="joy.joy.joy"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.joy.joy()</span></code></a> function, then print it to see the
trace.</p> trace.</p>
<dl class="method"> <dl class="py method">
<dt id="joy.utils.pretty_print.TracePrinter.go"> <dt class="sig sig-object py" id="joy.utils.pretty_print.TracePrinter.go">
<code class="descname">go</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter.go"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter.go" title="Permalink to this definition"></a></dt> <span class="sig-name descname"><span class="pre">go</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter.go"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter.go" title="Permalink to this definition"></a></dt>
<dd><p>Return a list of strings, one for each entry in the history, prefixed <dd><p>Return a list of strings, one for each entry in the history, prefixed
with enough spaces to align all the interpreter dots.</p> with enough spaces to align all the interpreter dots.</p>
<p>This method is called internally by the <code class="docutils literal notranslate"><span class="pre">__str__()</span></code> method.</p> <p>This method is called internally by the <code class="docutils literal notranslate"><span class="pre">__str__()</span></code> method.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Return type</dt>
<col class="field-body" /> <dd class="field-odd"><p>list(str)</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body">list(str)</td> </dl>
</tr>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="method"> <dl class="py method">
<dt id="joy.utils.pretty_print.TracePrinter.viewer"> <dt class="sig sig-object py" id="joy.utils.pretty_print.TracePrinter.viewer">
<code class="descname">viewer</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter.viewer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter.viewer" title="Permalink to this definition"></a></dt> <span class="sig-name descname"><span class="pre">viewer</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">expression</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#TracePrinter.viewer"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.pretty_print.TracePrinter.viewer" title="Permalink to this definition"></a></dt>
<dd><p>Record the current stack and expression in the TracePrinter’s history. <dd><p>Record the current stack and expression in the TracePrinter’s history.
Pass this method as the <code class="docutils literal notranslate"><span class="pre">viewer</span></code> argument to the <a class="reference internal" href="joy.html#joy.joy.joy" title="joy.joy.joy"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.joy.joy()</span></code></a> function.</p> Pass this method as the <code class="docutils literal notranslate"><span class="pre">viewer</span></code> argument to the <a class="reference internal" href="joy.html#joy.joy.joy" title="joy.joy.joy"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.joy.joy()</span></code></a> function.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>quote</strong> (<em>stack</em>) – A stack.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple"> <li><p><strong>expression</strong> (<em>stack</em>) – A stack.</p></li>
<li><strong>quote</strong> (<em>stack</em>) – A stack.</li>
<li><strong>expression</strong> (<em>stack</em>) – A stack.</li>
</ul> </ul>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.pretty_print.trace"> <dt class="sig sig-object py" id="joy.utils.pretty_print.trace">
<code class="descclassname">joy.utils.pretty_print.</code><code class="descname">trace</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/utils/pretty_print.html#trace"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.pretty_print.trace" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.pretty_print.</span></span><span class="sig-name descname"><span class="pre">trace</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">expression</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dictionary</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/pretty_print.html#trace"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.pretty_print.trace" title="Permalink to this definition"></a></dt>
<dd><p>Evaluate a Joy expression on a stack and print a trace.</p> <dd><p>Evaluate a Joy expression on a stack and print a trace.</p>
<p>This function is just like the <cite>i</cite> combinator but it also prints a <p>This function is just like the <cite>i</cite> combinator but it also prints a
trace of the evaluation</p> trace of the evaluation</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>stack</strong> (<em>stack</em>) – The stack.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><p><strong>expression</strong> (<em>stack</em>) – The expression to evaluate.</p></li>
<li><strong>stack</strong> (<em>stack</em>) – The stack.</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><strong>expression</strong> (<em>stack</em>) – The expression to evaluate.</li>
<li><strong>dictionary</strong> (<em>dict</em>) – A <code class="docutils literal notranslate"><span class="pre">dict</span></code> mapping names to Joy functions.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Return type</dt>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">(stack, (), dictionary)</p> <dd class="field-even"><p>(stack, (), dictionary)</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Tracing Joy Execution</a><ul>
<li><a class="reference internal" href="#module-joy.utils.pretty_print"><code class="docutils literal notranslate"><span class="pre">joy.utils.pretty_print</span></code></a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Tracing Joy Execution</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#module-joy.utils.pretty_print"><code class="docutils literal notranslate"><span class="pre">joy.utils.pretty_print</span></code></a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -145,25 +154,24 @@ trace of the evaluation</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/pretty.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -174,7 +182,7 @@ trace of the evaluation</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

68
docs/sphinx_docs/_build/html/py-modindex.html
View File

@ -1,19 +1,17 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Python Module Index &#8212; Thun 0.4.1 documentation</title> <title>Python Module Index &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
@ -31,6 +29,8 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
@ -84,10 +84,34 @@
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="index.html">Documentation overview</a><ul> <li><a href="index.html">Documentation overview</a><ul>
@ -95,17 +119,23 @@
</ul> </ul>
</div> </div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -116,7 +146,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

91
docs/sphinx_docs/_build/html/search.html
View File

@ -1,27 +1,23 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Search &#8212; Thun 0.4.1 documentation</title> <title>Search &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/searchtools.js"></script> <script src="_static/searchtools.js"></script>
<script src="_static/language_data.js"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="#" /> <link rel="search" title="Search" href="#" />
<script type="text/javascript"> <script src="searchindex.js" defer></script>
jQuery(function() { Search.loadIndex("searchindex.js"); });
</script>
<script type="text/javascript" id="searchindexloader"></script>
<link rel="stylesheet" href="_static/custom.css" type="text/css" /> <link rel="stylesheet" href="_static/custom.css" type="text/css" />
@ -36,43 +32,84 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<h1 id="search-documentation">Search</h1> <h1 id="search-documentation">Search</h1>
<div id="fallback" class="admonition warning">
<script type="text/javascript">$('#fallback').hide();</script> <noscript>
<div class="admonition warning">
<p> <p>
Please activate JavaScript to enable the search Please activate JavaScript to enable the search
functionality. functionality.
</p> </p>
</div> </div>
</noscript>
<p> <p>
From here you can search these documents. Enter your search Searching for multiple words only shows matches that contain
words into the box below and click "search". Note that the search all words.
function will automatically search for all of the words. Pages
containing fewer words won't appear in the result list.
</p> </p>
<form action="" method="get"> <form action="" method="get">
<input type="text" name="q" value="" /> <input type="text" name="q" aria-labelledby="search-documentation" value="" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="search" /> <input type="submit" value="search" />
<span id="search-progress" style="padding-left: 10px"></span> <span id="search-progress" style="padding-left: 10px"></span>
</form> </form>
<div id="search-results"> <div id="search-results">
</div> </div>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"><div class="relations"> <div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">Thun</a></h1>
<h3>Navigation</h3>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul>
<div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
<li><a href="index.html">Documentation overview</a><ul> <li><a href="index.html">Documentation overview</a><ul>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -83,7 +120,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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

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

File diff suppressed because one or more lines are too long

285
docs/sphinx_docs/_build/html/stack.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Stack or Quote or Sequence or List… &#8212; Thun 0.4.1 documentation</title> <title>Stack or Quote or Sequence or List… &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Parsing Text into Joy Expressions" href="parser.html" /> <link rel="next" title="Parsing Text into Joy Expressions" href="parser.html" />
@ -30,11 +29,13 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="stack-or-quote-or-sequence-or-list"> <section id="stack-or-quote-or-sequence-or-list">
<h1>Stack or Quote or Sequence or List…<a class="headerlink" href="#stack-or-quote-or-sequence-or-list" title="Permalink to this headline"></a></h1> <h1>Stack or Quote or Sequence or List…<a class="headerlink" href="#stack-or-quote-or-sequence-or-list" title="Permalink to this headline"></a></h1>
<div class="section" id="module-joy.utils.stack"> <section id="module-joy.utils.stack">
<span id="joy-utils-stack"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.utils.stack</span></code><a class="headerlink" href="#module-joy.utils.stack" title="Permalink to this headline"></a></h2> <span id="joy-utils-stack"></span><h2><code class="docutils literal notranslate"><span class="pre">joy.utils.stack</span></code><a class="headerlink" href="#module-joy.utils.stack" title="Permalink to this headline"></a></h2>
<p>When talking about Joy we use the terms “stack”, “quote”, “sequence”, <p>When talking about Joy we use the terms “stack”, “quote”, “sequence”,
“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
@ -44,7 +45,7 @@ values from (at least) one end.</p>
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
recursive form of a stack with one or more items on it:</p> recursive form of a stack with one or more items on it:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stack</span> <span class="p">:</span><span class="o">=</span> <span class="p">()</span> <span class="o">|</span> <span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stack</span> <span class="o">:=</span> <span class="p">()</span> <span class="o">|</span> <span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span>
</pre></div> </pre></div>
</div> </div>
<p>Putting some numbers onto a stack:</p> <p>Putting some numbers onto a stack:</p>
@ -59,7 +60,7 @@ recursive form of a stack with one or more items on it:</p>
means we can directly “unpack” the expected arguments to a Joy function.</p> means we can directly “unpack” the expected arguments to a Joy function.</p>
<p>For example:</p> <p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">((</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)):</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">((</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)):</span>
<span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span> <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
</pre></div> </pre></div>
</div> </div>
<p>We replace the argument “stack” by the expected structure of the stack, <p>We replace the argument “stack” by the expected structure of the stack,
@ -71,8 +72,8 @@ where they would be redundant.)</p>
web page, doesn’t handle tuples in the function parameters. And in Python 3, this web page, doesn’t handle tuples in the function parameters. And in Python 3, this
syntax was removed entirely. Instead you would have to write:</p> syntax was removed entirely. Instead you would have to write:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">stack</span> <span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span> <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
</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
@ -80,155 +81,168 @@ iterable 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>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.concat"> <dt class="sig sig-object py" id="joy.utils.stack.concat">
<code class="descclassname">joy.utils.stack.</code><code class="descname">concat</code><span class="sig-paren">(</span><em>quote</em>, <em>expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#concat"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.concat" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">concat</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">quote</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">expression</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#concat"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.concat" title="Permalink to this definition"></a></dt>
<dd><p>Concatinate quote onto expression.</p> <dd><p>Concatinate quote onto expression.</p>
<p>In joy [1 2] [3 4] would become [1 2 3 4].</p> <p>In joy [1 2] [3 4] would become [1 2 3 4].</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>quote</strong> (<em>stack</em>) – A stack.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><p><strong>expression</strong> (<em>stack</em>) – A stack.</p></li>
<li><strong>quote</strong> (<em>stack</em>) – A stack.</li>
<li><strong>expression</strong> (<em>stack</em>) – A stack.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Raises</dt>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><strong>RuntimeError</strong> – if quote is larger than sys.getrecursionlimit().</p> <dd class="field-even"><p><strong>RuntimeError</strong> – if quote is larger than sys.getrecursionlimit().</p>
</td> </dd>
</tr> <dt class="field-odd">Return type</dt>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">stack</p> <dd class="field-odd"><p>stack</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.expression_to_string"> <dt class="sig sig-object py" id="joy.utils.stack.dnd">
<code class="descclassname">joy.utils.stack.</code><code class="descname">expression_to_string</code><span class="sig-paren">(</span><em>expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#expression_to_string"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.expression_to_string" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">dnd</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">from_index</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">to_index</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#dnd"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.dnd" title="Permalink to this definition"></a></dt>
<dd><p>Given a stack and two indices return a rearranged stack.
First remove the item at from_index and then insert it at to_index,
the second index is relative to the stack after removal of the item
at from_index.</p>
<p>This function reuses all of the items and as much of the stack as it
can. It’s meant to be used by remote clients to support drag-n-drop
rearranging of the stack from e.g. the StackListbox.</p>
</dd></dl>
<dl class="py function">
<dt class="sig sig-object py" id="joy.utils.stack.expression_to_string">
<span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">expression_to_string</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">expression</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#expression_to_string"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.expression_to_string" title="Permalink to this definition"></a></dt>
<dd><p>Return a “pretty print” string for a expression.</p> <dd><p>Return a “pretty print” string for a expression.</p>
<p>The items are written left-to-right:</p> <p>The items are written left-to-right:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="o">...</span><span class="p">))</span> <span class="o">-&gt;</span> <span class="s1">&#39;top second ...&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="o">...</span><span class="p">))</span> <span class="o">-&gt;</span> <span class="s1">&#39;top second ...&#39;</span>
</pre></div> </pre></div>
</div> </div>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><p><strong>expression</strong> (<em>stack</em>) – A stack.</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>expression</strong> (<em>stack</em>) – A stack.</td> <dt class="field-even">Return type</dt>
</tr> <dd class="field-even"><p>str</p>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body">str</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.iter_stack"> <dt class="sig sig-object py" id="joy.utils.stack.iter_stack">
<code class="descclassname">joy.utils.stack.</code><code class="descname">iter_stack</code><span class="sig-paren">(</span><em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#iter_stack"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.iter_stack" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">iter_stack</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#iter_stack"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.iter_stack" title="Permalink to this definition"></a></dt>
<dd><p>Iterate through the items on the stack.</p> <dd><p>Iterate through the items on the stack.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><p><strong>stack</strong> (<em>stack</em>) – A stack.</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>stack</strong> (<em>stack</em>) – A stack.</td> <dt class="field-even">Return type</dt>
</tr> <dd class="field-even"><p>iterator</p>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body">iterator</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.list_to_stack"> <dt class="sig sig-object py" id="joy.utils.stack.list_to_stack">
<code class="descclassname">joy.utils.stack.</code><code class="descname">list_to_stack</code><span class="sig-paren">(</span><em>el</em>, <em>stack=()</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#list_to_stack"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.list_to_stack" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">list_to_stack</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">el</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">stack</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">()</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#list_to_stack"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.list_to_stack" title="Permalink to this definition"></a></dt>
<dd><p>Convert a Python list (or other sequence) to a Joy stack:</p> <dd><p>Convert a Python list (or other sequence) to a Joy stack:</p>
<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="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="o">-&gt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">())))</span> <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="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="o">-&gt;</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">())))</span>
</pre></div> </pre></div>
</div> </div>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>el</strong> (<em>list</em>) – A Python list or other sequence (iterators and generators
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> 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><strong>el</strong> (<em>list</em>) – A Python list or other sequence (iterators and generators <li><p><strong>stack</strong> (<em>stack</em>) – A stack, optional, defaults to the empty stack.</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>.)</li>
<li><strong>stack</strong> (<em>stack</em>) – A stack, optional, defaults to the empty stack.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Return type</dt>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">stack</p> <dd class="field-even"><p>stack</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.pick"> <dt class="sig sig-object py" id="joy.utils.stack.pick">
<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>stack</em>, <em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">pick</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition"></a></dt>
<dd><p>Return the nth item on the stack.</p> <dd><p>Return the nth item on the stack.</p>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><ul class="simple">
<tbody valign="top"> <li><p><strong>stack</strong> (<em>stack</em>) – A stack.</p></li>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><p><strong>n</strong> (<em>int</em>) – An index into the stack.</p></li>
<li><strong>stack</strong> (<em>stack</em>) – A stack.</li>
<li><strong>n</strong> (<em>int</em>) – An index into the stack.</li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-even">Raises</dt>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><ul class="first simple"> <dd class="field-even"><ul class="simple">
<li><strong>ValueError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is less than zero.</li> <li><p><strong>ValueError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is less than zero.</p></li>
<li><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">stack</span></code>.</li> <li><p><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">stack</span></code>.</p></li>
</ul> </ul>
</td> </dd>
</tr> <dt class="field-odd">Return type</dt>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">whatever</p> <dd class="field-odd"><p>whatever</p>
</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="py function">
<dt id="joy.utils.stack.stack_to_string"> <dt class="sig sig-object py" id="joy.utils.stack.stack_to_string">
<code class="descclassname">joy.utils.stack.</code><code class="descname">stack_to_string</code><span class="sig-paren">(</span><em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#stack_to_string"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.stack_to_string" title="Permalink to this definition"></a></dt> <span class="sig-prename descclassname"><span class="pre">joy.utils.stack.</span></span><span class="sig-name descname"><span class="pre">stack_to_string</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">stack</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#stack_to_string"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#joy.utils.stack.stack_to_string" title="Permalink to this definition"></a></dt>
<dd><p>Return a “pretty print” string for a stack.</p> <dd><p>Return a “pretty print” string for a stack.</p>
<p>The items are written right-to-left:</p> <p>The items are written right-to-left:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="o">...</span><span class="p">))</span> <span class="o">-&gt;</span> <span class="s1">&#39;... second top&#39;</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="p">(</span><span class="n">second</span><span class="p">,</span> <span class="o">...</span><span class="p">))</span> <span class="o">-&gt;</span> <span class="s1">&#39;... second top&#39;</span>
</pre></div> </pre></div>
</div> </div>
<table class="docutils field-list" frame="void" rules="none"> <dl class="field-list simple">
<col class="field-name" /> <dt class="field-odd">Parameters</dt>
<col class="field-body" /> <dd class="field-odd"><p><strong>stack</strong> (<em>stack</em>) – A stack.</p>
<tbody valign="top"> </dd>
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>stack</strong> (<em>stack</em>) – A stack.</td> <dt class="field-even">Return type</dt>
</tr> <dd class="field-even"><p>str</p>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body">str</td> </dd>
</tr> </dl>
</tbody>
</table>
</dd></dl> </dd></dl>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Stack or Quote or Sequence or List…</a><ul>
<li><a class="reference internal" href="#module-joy.utils.stack"><code class="docutils literal notranslate"><span class="pre">joy.utils.stack</span></code></a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Stack or Quote or Sequence or List…</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#module-joy.utils.stack"><code class="docutils literal notranslate"><span class="pre">joy.utils.stack</span></code></a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Type Inference of Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -238,25 +252,24 @@ won’t work because <code class="docutils literal notranslate"><span class="pre
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/stack.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -267,7 +280,7 @@ won’t work because <code class="docutils literal notranslate"><span class="pre
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>

85
docs/sphinx_docs/_build/html/types.html
View File

@ -1,19 +1,18 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <!DOCTYPE html>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<title>Type Inference of Joy Expressions &#8212; Thun 0.4.1 documentation</title> <title>Type Inference of Joy Expressions &#8212; Thun 0.4.1 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <link rel="stylesheet" type="text/css" href="_static/alabaster.css" />
<script type="text/javascript" src="_static/documentation_options.js"></script> <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script> <script src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script> <script src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script> <script src="_static/doctools.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" /> <link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" /> <link rel="search" title="Search" href="search.html" />
<link rel="next" title="Essays about Programming in Joy" href="notebooks/index.html" /> <link rel="next" title="Essays about Programming in Joy" href="notebooks/index.html" />
@ -30,9 +29,11 @@
<div class="document"> <div class="document">
<div class="documentwrapper"> <div class="documentwrapper">
<div class="bodywrapper"> <div class="bodywrapper">
<div class="body" role="main"> <div class="body" role="main">
<div class="section" id="type-inference-of-joy-expressions"> <section id="type-inference-of-joy-expressions">
<h1>Type Inference of Joy Expressions<a class="headerlink" href="#type-inference-of-joy-expressions" title="Permalink to this headline"></a></h1> <h1>Type Inference of Joy Expressions<a class="headerlink" href="#type-inference-of-joy-expressions" title="Permalink to this headline"></a></h1>
<p>UPDATE: May 2020 - I removed the type inference code in <cite>joy.utils.types</cite> <p>UPDATE: May 2020 - I removed the type inference code in <cite>joy.utils.types</cite>
but you can find it in the <cite>v0.4.0</cite> tag here: but you can find it in the <cite>v0.4.0</cite> tag here:
@ -44,7 +45,7 @@ functions, and a more complex inferencer/interpreter hybrid that can
infer the stack effects of most Joy expressions, including multiple stack infer the stack effects of most Joy expressions, including multiple stack
effects, unbounded sequences of values, and combinators (if enough effects, unbounded sequences of values, and combinators (if enough
information is available.)</p> information is available.)</p>
<div class="section" id="joy-utils-types"> <section id="joy-utils-types">
<h2><code class="docutils literal notranslate"><span class="pre">joy.utils.types</span></code><a class="headerlink" href="#joy-utils-types" title="Permalink to this headline"></a></h2> <h2><code class="docutils literal notranslate"><span class="pre">joy.utils.types</span></code><a class="headerlink" href="#joy-utils-types" title="Permalink to this headline"></a></h2>
<p>Curently (asterix after name indicates a function that can be <p>Curently (asterix after name indicates a function that can be
auto-compiled to Python):</p> auto-compiled to Python):</p>
@ -173,22 +174,41 @@ far.</p>
(i2 i1 -- i3) (i2 i1 -- i3)
</pre></div> </pre></div>
</div> </div>
</div> </section>
</div> </section>
</div> </div>
</div> </div>
</div> </div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper"> <div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3> <h1 class="logo"><a href="index.html">Thun</a></h1>
<ul>
<li><a class="reference internal" href="#">Type Inference of Joy Expressions</a><ul>
<li><a class="reference internal" href="#joy-utils-types"><code class="docutils literal notranslate"><span class="pre">joy.utils.types</span></code></a></li>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="notebooks/Intro.html">Thun: Joy in Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="joy.html">Joy Interpreter</a></li>
<li class="toctree-l1"><a class="reference internal" href="stack.html">Stack or Quote or Sequence or List…</a></li>
<li class="toctree-l1"><a class="reference internal" href="parser.html">Parsing Text into Joy Expressions</a></li>
<li class="toctree-l1"><a class="reference internal" href="pretty.html">Tracing Joy Execution</a></li>
<li class="toctree-l1"><a class="reference internal" href="library.html">Function Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="lib.html">Functions Grouped by, er, Function with Examples</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Type Inference of Joy Expressions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#joy-utils-types"><code class="docutils literal notranslate"><span class="pre">joy.utils.types</span></code></a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="notebooks/index.html">Essays about Programming in Joy</a></li>
</ul> </ul>
<div class="relations"> <div class="relations">
<h3>Related Topics</h3> <h3>Related Topics</h3>
<ul> <ul>
@ -198,25 +218,24 @@ far.</p>
</ul></li> </ul></li>
</ul> </ul>
</div> </div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/types.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search"> <div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3> <h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper"> <div class="searchformwrapper">
<form class="search" action="search.html" method="get"> <form class="search" action="search.html" method="get">
<input type="text" name="q" /> <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" /> <input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form> </form>
</div> </div>
</div> </div>
<script type="text/javascript">$('#searchbox').show(0);</script> <script>$('#searchbox').show(0);</script>
</div> </div>
</div> </div>
<div class="clearer"></div> <div class="clearer"></div>
@ -227,7 +246,7 @@ far.</p>
</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> 1.7.3. Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
</div> </div>
</body> </body>