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

Rebuilt some docs. Minor edits.

This commit is contained in:
Simon Forman 2020-04-24 16:10:28 -07:00
parent 1863cba7f7
commit 14f706cd96
22 changed files with 1949 additions and 2542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

226
docs/0._This_Implementation_of_Joy_in_Python.ipynb
View File

@ -67,57 +67,56 @@
"name": "stdout",
"output_type": "stream",
"text": [
"§ Stack\n",
"When talking about Joy we use the terms \"stack\", \"quote\", \"sequence\",\n",
"\"list\", and others to mean the same thing: a simple linear datatype that\n",
"permits certain operations such as iterating and pushing and popping\n",
"values from (at least) one end.\n",
"\n",
"There is no \"Stack\" Python class, instead we use the `cons list`_, a \n",
"venerable two-tuple recursive sequence datastructure, where the\n",
"empty tuple ``()`` is the empty stack and ``(head, rest)`` gives the recursive\n",
"form of a stack with one or more items on it::\n",
"\n",
"When talking about Joy we use the terms \"stack\", \"list\", \"sequence\" and\n",
"\"aggregate\" to mean the same thing: a simple datatype that permits\n",
"certain operations such as iterating and pushing and popping values from\n",
"(at least) one end.\n",
" stack := () | (item, stack)\n",
"\n",
"We use the venerable two-tuple recursive form of sequences where the\n",
"empty tuple () is the empty stack and (head, rest) gives the recursive\n",
"form of a stack with one or more items on it.\n",
"Putting some numbers onto a stack::\n",
"\n",
" ()\n",
" (1, ())\n",
" (2, (1, ()))\n",
" (3, (2, (1, ())))\n",
" ...\n",
"\n",
"And so on.\n",
"\n",
"\n",
"We have two very simple functions to build up a stack from a Python\n",
"iterable and also to iterate through a stack and yield its items\n",
"one-by-one in order, and two functions to generate string representations\n",
"of stacks:\n",
"\n",
" list_to_stack()\n",
"\n",
" iter_stack()\n",
"\n",
" expression_to_string() (prints left-to-right)\n",
"\n",
" stack_to_string() (prints right-to-left)\n",
"\n",
"\n",
"A word about the stack data structure.\n",
" ()\n",
" (1, ())\n",
" (2, (1, ()))\n",
" (3, (2, (1, ())))\n",
" ...\n",
"\n",
"Python has very nice \"tuple packing and unpacking\" in its syntax which\n",
"means we can directly \"unpack\" the expected arguments to a Joy function.\n",
"\n",
"For example:\n",
"For example::\n",
"\n",
" def dup(stack):\n",
" head, tail = stack\n",
" return head, (head, tail)\n",
" def dup((head, tail)):\n",
" return head, (head, tail)\n",
"\n",
"We replace the argument \"stack\" by the expected structure of the stack,\n",
"in this case \"(head, tail)\", and Python takes care of de-structuring the\n",
"incoming argument and assigning values to the names. Note that Python\n",
"in this case \"(head, tail)\", and Python takes care of unpacking the\n",
"incoming tuple and assigning values to the names. (Note that Python\n",
"syntax doesn't require parentheses around tuples used in expressions\n",
"where they would be redundant.\n"
"where they would be redundant.)\n",
"\n",
"Unfortunately, the Sphinx documentation generator, which is used to generate this\n",
"web page, doesn't handle tuples in the function parameters. And in Python 3, this\n",
"syntax was removed entirely. Instead you would have to write::\n",
"\n",
" def dup(stack):\n",
" head, tail = stack\n",
" return head, (head, tail)\n",
"\n",
"\n",
"We have two very simple functions, one to build up a stack from a Python\n",
"iterable and another to iterate through a stack and yield its items\n",
"one-by-one in order. There are also two functions to generate string representations\n",
"of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions *internal stacks* are\n",
"printed left-to-right. These functions are written to support :doc:`../pretty`.\n",
"\n",
".. _cons list: https://en.wikipedia.org/wiki/Cons#Lists\n"
]
}
],
@ -237,22 +236,36 @@
"output_type": "stream",
"text": [
"def joy(stack, expression, dictionary, viewer=None):\n",
" '''\n",
" Evaluate the Joy expression on the stack.\n",
" '''\n",
" while expression:\n",
"\t'''Evaluate a Joy expression on a stack.\n",
"\n",
" if viewer: viewer(stack, expression)\n",
"\tThis function iterates through a sequence of terms which are either\n",
"\tliterals (strings, numbers, sequences of terms) or function symbols.\n",
"\tLiterals are put onto the stack and functions are looked up in the\n",
"\tdisctionary and executed.\n",
"\n",
" term, expression = expression\n",
" if isinstance(term, Symbol):\n",
" term = dictionary[term]\n",
" stack, expression, dictionary = term(stack, expression, dictionary)\n",
" else:\n",
" stack = term, stack\n",
"\tThe viewer is a function that is called with the stack and expression\n",
"\ton every iteration, its return value is ignored.\n",
"\n",
" if viewer: viewer(stack, expression)\n",
" return stack, expression, dictionary\n",
"\t:param stack stack: The stack.\n",
"\t:param stack expression: The expression to evaluate.\n",
"\t:param dict dictionary: A ``dict`` mapping names to Joy functions.\n",
"\t:param function viewer: Optional viewer function.\n",
"\t:rtype: (stack, (), dictionary)\n",
"\n",
"\t'''\n",
"\twhile expression:\n",
"\n",
"\t\tif viewer: viewer(stack, expression)\n",
"\n",
"\t\tterm, expression = expression\n",
"\t\tif isinstance(term, Symbol):\n",
"\t\t\tterm = dictionary[term]\n",
"\t\t\tstack, expression, dictionary = term(stack, expression, dictionary)\n",
"\t\telse:\n",
"\t\t\tstack = term, stack\n",
"\n",
"\tif viewer: viewer(stack, expression)\n",
"\treturn stack, expression, dictionary\n",
"\n"
]
}
@ -304,19 +317,22 @@
"name": "stdout",
"output_type": "stream",
"text": [
"§ Converting text to a joy expression.\n",
"This module exports a single function for converting text to a joy\n",
"expression as well as a single Symbol class and a single Exception type.\n",
"\n",
"This module exports a single function:\n",
"The Symbol string class is used by the interpreter to recognize literals\n",
"by the fact that they are not Symbol objects.\n",
"\n",
" text_to_expression(text)\n",
"A crude grammar::\n",
"\n",
"As well as a single Symbol class and a single Exception type:\n",
" joy = term*\n",
" term = int | float | string | '[' joy ']' | symbol\n",
"\n",
" ParseError\n",
"\n",
"When supplied with a string this function returns a Python datastructure\n",
"that represents the Joy datastructure described by the text expression.\n",
"Any unbalanced square brackets will raise a ParseError.\n"
"A Joy expression is a sequence of zero or more terms. A term is a\n",
"literal value (integer, float, string, or Joy expression) or a function\n",
"symbol. Function symbols are unquoted strings and cannot contain square\n",
"brackets. Terms must be separated by blanks, which can be omitted\n",
"around square brackets.\n"
]
}
],
@ -343,27 +359,27 @@
"output_type": "stream",
"text": [
"def _parse(tokens):\n",
" '''\n",
" Return a stack/list expression of the tokens.\n",
" '''\n",
" frame = []\n",
" stack = []\n",
" for tok in tokens:\n",
" if tok == '[':\n",
" stack.append(frame)\n",
" frame = []\n",
" stack[-1].append(frame)\n",
" elif tok == ']':\n",
" try:\n",
" frame = stack.pop()\n",
" except IndexError:\n",
" raise ParseError('One or more extra closing brackets.')\n",
" frame[-1] = list_to_stack(frame[-1])\n",
" else:\n",
" frame.append(tok)\n",
" if stack:\n",
" raise ParseError('One or more unclosed brackets.')\n",
" return list_to_stack(frame)\n",
"\t'''\n",
"\tReturn a stack/list expression of the tokens.\n",
"\t'''\n",
"\tframe = []\n",
"\tstack = []\n",
"\tfor tok in tokens:\n",
"\t\tif tok == '[':\n",
"\t\t\tstack.append(frame)\n",
"\t\t\tframe = []\n",
"\t\t\tstack[-1].append(frame)\n",
"\t\telif tok == ']':\n",
"\t\t\ttry:\n",
"\t\t\t\tframe = stack.pop()\n",
"\t\t\texcept IndexError:\n",
"\t\t\t\traise ParseError('Extra closing bracket.')\n",
"\t\t\tframe[-1] = list_to_stack(frame[-1])\n",
"\t\telse:\n",
"\t\t\tframe.append(tok)\n",
"\tif stack:\n",
"\t\traise ParseError('Unclosed bracket.')\n",
"\treturn list_to_stack(frame)\n",
"\n"
]
}
@ -498,7 +514,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
"!= % & * *fraction *fraction0 + ++ - -- / < << <= <> = > >= >> ? ^ add anamorphism and app1 app2 app3 average b binary branch choice clear cleave concat cons dinfrirst dip dipd dipdd disenstacken div down_to_zero dudipd dup dupd dupdip enstacken eq first flatten floordiv gcd ge genrec getitem gt help i id ifte infra le least_fraction loop lshift lt map min mod modulus mul ne neg not nullary or over pam parse pm pop popd popdd popop pow pred primrec product quoted range range_to_zero rem remainder remove rest reverse roll< roll> rolldown rollup rshift run second select sharing shunt size sqr sqrt stack step sub succ sum swaack swap swoncat swons ternary third times truediv truthy tuck unary uncons unit unquoted unstack void warranty while words x xor zip •\n"
"!= % & * *fraction *fraction0 + ++ - -- / // /floor < << <= <> = > >= >> ? ^ _Tree_add_Ee _Tree_delete_R0 _Tree_delete_clear_stuff _Tree_get_E abs add anamorphism and app1 app2 app3 at average b binary bool branch ccons choice clear cleave cmp codireco concat cond cons dinfrirst dip dipd dipdd disenstacken divmod down_to_zero drop dup dupd dupdd dupdip dupdipd enstacken eq first first_two flatten floor floordiv fork fourth gcd ge genrec getitem gt help i id ifte ii infer infra inscribe le least_fraction loop lshift lt make_generator map max min mod modulus mul ne neg not nullary of or over pam parse pick pm pop popd popdd popop popopd popopdd pow pred primrec product quoted range range_to_zero rem remainder remove rest reverse roll< roll> rolldown rollup round rrest rshift run second select sharing shunt size sort sqr sqrt stack step step_zero stuncons stununcons sub succ sum swaack swap swons take ternary third times truediv truthy tuck unary uncons unique unit unquoted unstack unswons void warranty while words x xor zip •\n"
]
}
],
@ -524,10 +540,24 @@
"name": "stdout",
"output_type": "stream",
"text": [
"@inscribe\n",
"@combinator_effect(_COMB_NUMS(), a1, s1)\n",
"@FunctionWrapper\n",
"def dip(stack, expression, dictionary):\n",
" (quote, (x, stack)) = stack\n",
" expression = x, expression\n",
" return stack, pushback(quote, expression), dictionary\n",
"\t'''\n",
"\tThe dip combinator expects a quoted program on the stack and below it\n",
"\tsome item, it hoists the item into the expression and runs the program\n",
"\ton the rest of the stack.\n",
"\t::\n",
"\n",
"\t\t\t ... x [Q] dip\n",
"\t\t-------------------\n",
"\t\t\t\t ... Q x\n",
"\n",
"\t'''\n",
"\t(quote, (x, stack)) = stack\n",
"\texpression = (x, expression)\n",
"\treturn stack, concat(quote, expression), dictionary\n",
"\n"
]
}
@ -552,28 +582,26 @@
"name": "stdout",
"output_type": "stream",
"text": [
"second == rest first\n",
"third == rest rest first\n",
"ii == [dip] dupdip i\n",
"of == swap at\n",
"product == 1 swap [*] step\n",
"swons == swap cons\n",
"swoncat == swap concat\n",
"flatten == [] swap [concat] step\n",
"unit == [] cons\n",
"quoted == [unit] dip\n",
"unquoted == [i] dip\n",
"enstacken == stack [clear] dip\n",
"disenstacken == ? [uncons ?] loop pop\n",
"? == dup truthy\n",
"disenstacken == ? [uncons ?] loop pop\n",
"dinfrirst == dip infra first\n",
"nullary == [stack] dinfrirst\n",
"unary == [stack [pop] dip] dinfrirst\n",
"binary == [stack [popop] dip] dinfrirst\n",
"ternary == [stack [popop pop] dip] dinfrirst\n",
"unary == nullary popd\n",
"binary == nullary [popop] dip\n",
"ternary == unary [popop] dip\n",
"pam == [i] map\n",
"run == [] swap infra\n",
"sqr == dup mul\n",
"size == 0 swap [pop ++] step\n",
"cleave == [i] app2 [popd] dip\n",
"fork == [i] app2\n",
"cleave == fork [popd] dip\n",
"average == [sum 1.0 *] [size] cleave /\n",
"gcd == 1 [tuck modulus dup 0 >] loop pop\n",
"least_fraction == dup [gcd] infra [div] concat map\n",
@ -584,8 +612,12 @@
"anamorphism == [pop []] swap [dip swons] genrec\n",
"range == [0 <=] [1 - dup] anamorphism\n",
"while == swap [nullary] cons dup dipd concat loop\n",
"dudipd == dup dipd\n",
"dupdipd == dup dipd\n",
"primrec == [i] genrec\n",
"step_zero == 0 roll> step\n",
"codireco == cons dip rest cons\n",
"make_generator == [codireco] ccons\n",
"ifte == [nullary not] dipd branch\n",
"\n"
]
}

7
docs/1._Basic_Use_of_Joy_in_a_Notebook.ipynb
View File

@ -214,6 +214,13 @@
"source": [
"V('96 27 gcd')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {

1461
docs/2._Library_Examples.ipynb
View File

File diff suppressed because it is too large Load Diff

19
docs/fun_with_scan.html
View File

@ -11773,7 +11773,7 @@ div#notebook {
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[1]:</div>
<div class="prompt input_prompt">In&nbsp;[2]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="kn">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>
@ -11789,6 +11789,7 @@ div#notebook {
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h1 id="On-&quot;Two-Exercises-Found-in-a-Book-on-Algorithmics&quot;">On "Two Exercises Found in a Book on Algorithmics"<a class="anchor-link" href="#On-&quot;Two-Exercises-Found-in-a-Book-on-Algorithmics&quot;">&#182;</a></h1><p>Bird &amp; Meertens</p>
<p><a href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614">PDF paper available here</a></p>
</div>
</div>
@ -11806,7 +11807,7 @@ div#notebook {
<blockquote><p>The problem is to find some definition of <code>scan</code> as a reduction. In other words, we have to find some function <code>f</code> and an operator <code>⨂</code> so that</p>
</blockquote>
<pre><code>⨂\x = f(a)⨂f(b)⨂...⨂f(z)</code></pre>
<pre><code>⨁\x = f(a)⨂f(b)⨂...⨂f(z)</code></pre>
</div>
</div>
@ -11941,7 +11942,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[2]:</div>
<div class="prompt input_prompt">In&nbsp;[3]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3] [size 1 &lt;=] [pop []] [[[+] infra] dupdip first] [dip swons] genrec&#39;</span><span class="p">)</span>
@ -11981,7 +11982,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[3]:</div>
<div class="prompt input_prompt">In&nbsp;[4]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3] [size 1 &lt;=] [[]] [[[+] infra] dupdip first] [dip swons] genrec&#39;</span><span class="p">)</span>
@ -12021,7 +12022,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[4]:</div>
<div class="prompt input_prompt">In&nbsp;[5]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3] [size 1 &lt;=] [] [[[+] infra] dupdip first] [dip swons] genrec&#39;</span><span class="p">)</span>
@ -12076,7 +12077,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[5]:</div>
<div class="prompt input_prompt">In&nbsp;[6]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">&#39;scan == [infra] cons [dupdip first] cons [size 1 &lt;=] [] roll&lt; [dip swons] genrec&#39;</span><span class="p">)</span>
@ -12089,7 +12090,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[6]:</div>
<div class="prompt input_prompt">In&nbsp;[7]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3 4] [+] scan&#39;</span><span class="p">)</span>
@ -12120,7 +12121,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[7]:</div>
<div class="prompt input_prompt">In&nbsp;[8]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3 4] [*] scan&#39;</span><span class="p">)</span>
@ -12151,7 +12152,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In&nbsp;[8]:</div>
<div class="prompt input_prompt">In&nbsp;[9]:</div>
<div class="inner_cell">
<div class="input_area">
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">&#39;[1 2 3 4 5 6 7] [neg +] scan&#39;</span><span class="p">)</span>

4
docs/fun_with_scan.md
View File

@ -8,6 +8,8 @@ from notebook_preamble import D, DefinitionWrapper, J, V, define
Bird & Meertens
[PDF paper available here](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614)
## Define `scan` in terms of a reduction.
> Problem I. The reduction operator `/` of APL takes some binary operator `⨁` on its left and a vector `x` of values on its right. The meaning of `⨁/x` for `x = [a b ... z]` is the value `a⨁b⨁...⨁z`. For this to be well-defined in the absence of brackets, the operation `⨁` has to be associative. Now there is another operator `\` of APL called `scan`. Its effect is closely related to reduction in that we have:
@ -16,7 +18,7 @@ Bird & Meertens
> The problem is to find some definition of `scan` as a reduction. In other words, we have to find some function `f` and an operator `⨂` so that
⨂\x = f(a)⨂f(b)⨂...⨂f(z)
⨁\x = f(a)⨂f(b)⨂...⨂f(z)
## Designing the Recursive Function
Ignoring the exact requirements (finding `f` and `⨂`) can we implement `scan` as a hylomorphism in Joy?

5
docs/fun_with_scan.rst
View File

@ -8,6 +8,9 @@ On "Two Exercises Found in a Book on Algorithmics"
Bird & Meertens
`PDF paper available
here <https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614>`__
Define ``scan`` in terms of a reduction.
----------------------------------------
@ -29,7 +32,7 @@ Define ``scan`` in terms of a reduction.
::
⨂\x = f(a)⨂f(b)⨂...⨂f(z)
⨁\x = f(a)⨂f(b)⨂...⨂f(z)
Designing the Recursive Function
--------------------------------

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

@ -36,7 +36,6 @@
<li><a href="joy/library.html">joy.library</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/polytypes.html">joy.utils.polytypes</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/types.html">joy.utils.types</a></li>

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

@ -57,10 +57,7 @@
<span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="k">try</span><span class="p">:</span>
<span class="nb">input</span> <span class="o">=</span> <span class="n">raw_input</span>
<span class="k">except</span> <span class="ne">NameError</span><span class="p">:</span>
<span class="k">pass</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">input</span>
<span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="p">,</span> <span class="n">format_exc</span>
<span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">ParseError</span><span class="p">,</span> <span class="n">Symbol</span>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">stack_to_string</span>
@ -68,86 +65,89 @@
<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 the Joy expression on the stack.</span>
<span class="sd"> </span>
<span class="sd"> The basic joy() function is quite straightforward. It iterates through a</span>
<span class="sd"> sequence of terms which are either literals (strings, numbers, sequences)</span>
<span class="sd"> or functions. Literals are put onto the stack and functions are</span>
<span class="sd"> executed.</span>
<span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a 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 dict dictionary: A ``dict`` mapping names to Joy functions.</span>
<span class="sd"> :param function viewer: Optional viewer function.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</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 are put onto the stack and functions are looked up in the</span>
<span class="sd"> disctionary and executed.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">while</span> <span class="n">expression</span><span class="p">:</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="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="sd"> :param stack stack: The stack.</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 function viewer: Optional viewer function.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</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="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="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="sd"> &#39;&#39;&#39;</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">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">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="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="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">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>
<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">&#39;&#39;&#39;</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 stack stack: The stack.</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"> :rtype: (stack, (), dictionary)</span>
<span class="sd"> :param str text: Joy code.</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 function viewer: Optional viewer function.</span>
<span class="sd"> :rtype: (stack, (), dictionary)</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="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="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="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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Read-Evaluate-Print Loop</span>
<span class="sd">&#39;&#39;&#39;</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 dict dictionary: A ``dict`` mapping names to Joy functions.</span>
<span class="sd"> :rtype: 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"> :rtype: stack</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="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="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="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="n">viewer</span> <span class="o">=</span> <span class="n">TracePrinter</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">viewer</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="n">exc</span> <span class="o">=</span> <span class="n">format_exc</span><span class="p">()</span> <span class="c1"># Capture the exception.</span>
<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="c1"># Print the Joy trace.</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="n">exc</span><span class="p">)</span> <span class="c1"># Print the original exception.</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
<span class="k">except</span><span class="p">:</span>
<span class="n">print_exc</span><span class="p">()</span>
<span class="nb">print</span><span class="p">()</span>
<span class="k">return</span> <span class="n">stack</span></div>
<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="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="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="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="n">viewer</span> <span class="o">=</span> <span class="n">TracePrinter</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">viewer</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="n">exc</span> <span class="o">=</span> <span class="n">format_exc</span><span class="p">()</span> <span class="c1"># Capture the exception.</span>
<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="c1"># Print the Joy trace.</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="n">exc</span><span class="p">)</span> <span class="c1"># Print the original exception.</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
<span class="k">except</span><span class="p">:</span>
<span class="n">print_exc</span><span class="p">()</span>
<span class="nb">print</span><span class="p">()</span>
<span class="k">return</span> <span class="n">stack</span></div>
</pre></div>
</div>

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

File diff suppressed because it is too large Load Diff

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

@ -59,90 +59,102 @@
<span class="sd">A crude grammar::</span>
<span class="sd"> joy = term*</span>
<span class="sd"> term = int | float | string | &#39;[&#39; joy &#39;]&#39; | function</span>
<span class="sd">A Joy expression is a sequence of zero or more terms</span>
<span class="sd"> joy = term*</span>
<span class="sd"> term = int | float | string | &#39;[&#39; joy &#39;]&#39; | symbol</span>
<span class="sd">A Joy expression is a sequence of zero or more terms. A term is a</span>
<span class="sd">literal value (integer, float, string, or Joy expression) or a function</span>
<span class="sd">symbol. Function symbols are unquoted strings and cannot contain square</span>
<span class="sd">brackets. Terms must be separated by blanks, which can be omitted</span>
<span class="sd">around square brackets.</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="c1">#TODO: explain the details of float lits and strings.</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">.utils.stack</span> <span class="k">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*&#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">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>
<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="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div>
<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>
<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"> 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"> 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"> Any unbalanced square brackets will raise a ParseError.</span>
<span class="sd"> :param str text: Text to convert.</span>
<span class="sd"> :rtype: stack</span>
<span class="sd"> :raises ParseError: if the parse fails.</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="sd"> :param str text: Text to convert.</span>
<span class="sd"> :rtype: stack</span>
<span class="sd"> :raises ParseError: if the parse fails.</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>
<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="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"> &#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="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="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="p">)</span>
<span class="k">return</span> <span class="n">tokens</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="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="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="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="p">)</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="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a stack/list expression of the tokens.</span>
<span class="sd"> &#39;&#39;&#39;</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="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="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">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">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="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="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">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="n">tok</span><span class="p">)</span>
<span class="k">if</span> <span class="n">stack</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">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a stack/list expression of the tokens.</span>
<span class="sd"> &#39;&#39;&#39;</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="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="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">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">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="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="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">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="n">tok</span><span class="p">)</span>
<span class="k">if</span> <span class="n">stack</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">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</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="p">(</span><span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*&#39;</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="p">(</span><span class="sa">r</span><span class="s1">&#39;-?\d+&#39;</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="p">(</span><span class="sa">r</span><span class="s1">&#39;[•\w!@$%^&amp;*()_+&lt;&gt;?|\/;:`~,.=-]+&#39;</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="p">(</span><span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</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="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="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="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="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="sa">r</span><span class="s1">&#39;\s+&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</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="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="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="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">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>
</div>

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

@ -73,62 +73,63 @@
<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="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">object</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">.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>
<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"> 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"> trace.</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"> method to the :py:func:`joy.joy.joy` function, then print it to see the</span>
<span class="sd"> trace.</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="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="p">[]</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="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>
<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"> Pass this method as the ``viewer`` argument to the :py:func:`joy.joy.joy` function.</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"> 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"> :param stack quote: A stack.</span>
<span class="sd"> :param stack expression: A stack.</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="sd"> :param stack quote: A stack.</span>
<span class="sd"> :param stack expression: A stack.</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="k">def</span> <span class="nf">__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">def</span> <span class="nf">__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>
<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"> 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>
<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"> 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"> 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"> &#39;&#39;&#39;</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="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">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="k">if</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="n">max_stack_length</span><span class="p">:</span>
<span class="n">max_stack_length</span> <span class="o">=</span> <span class="n">n</span>
<span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> . </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
<span class="k">return</span> <span class="p">[</span> <span class="c1"># Prefix spaces to line up &#39;.&#39;s.</span>
<span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="o">*</span> <span class="p">(</span><span class="n">max_stack_length</span> <span class="o">-</span> <span class="n">length</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">)</span>
<span class="k">for</span> <span class="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span>
<span class="p">]</span></div>
<span class="sd"> :rtype: list(str)</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">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="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">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="n">max_stack_length</span><span class="p">:</span>
<span class="n">max_stack_length</span> <span class="o">=</span> <span class="n">n</span>
<span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> . </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
<span class="k">return</span> <span class="p">[</span> <span class="c1"># Prefix spaces to line up &#39;.&#39;s.</span>
<span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="o">*</span> <span class="p">(</span><span class="n">max_stack_length</span> <span class="o">-</span> <span class="n">length</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">)</span>
<span class="k">for</span> <span class="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span>
<span class="p">]</span></div>
<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="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="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="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="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="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>
</pre></div>
</div>

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

@ -76,8 +76,8 @@
<span class="sd">For example::</span>
<span class="sd"> def dup((head, tail)):</span>
<span class="sd"> return head, (head, tail)</span>
<span class="sd"> def dup((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">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">syntax was removed entirely. Instead you would have to write::</span>
<span class="sd"> def dup(stack):</span>
<span class="sd"> head, tail = stack</span>
<span class="sd"> return head, (head, tail)</span>
<span class="sd"> def dup(stack):</span>
<span class="sd"> head, tail = stack</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>
@ -105,98 +105,97 @@
<span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span>
<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"> 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"> :rtype: stack</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"> :param stack stack: A stack, optional, defaults to the empty stack.</span>
<span class="sd"> :rtype: stack</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="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="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="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>
<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"> :rtype: iterator</span>
<span class="sd"> &#39;&#39;&#39;</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="k">yield</span> <span class="n">item</span></div>
<span class="sd"> :param stack stack: A stack.</span>
<span class="sd"> :rtype: iterator</span>
<span class="sd"> &#39;&#39;&#39;</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="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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a &quot;pretty print&quot; string for a stack.</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"> 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"> :rtype: str</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="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="sd"> :param stack stack: A stack.</span>
<span class="sd"> :rtype: str</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="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>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a &quot;pretty print&quot; string for a expression.</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"> 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"> :rtype: str</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="sd"> :param stack expression: A stack.</span>
<span class="sd"> :rtype: str</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">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="nb">isinstance</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">long</span><span class="p">):</span> <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s1">&#39;L&#39;</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="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">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="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="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="k">else</span> <span class="nb">str</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s1">&#39;L&#39;</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="n">long</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="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="k">else</span> <span class="nb">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>
<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 expression: A stack.</span>
<span class="sd"> :raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
<span class="sd"> :rtype: stack</span>
<span class="sd"> &#39;&#39;&#39;</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"># on quotes longer than sys.getrecursionlimit().</span>
<span class="sd"> :param stack quote: A stack.</span>
<span class="sd"> :param stack expression: A stack.</span>
<span class="sd"> :raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
<span class="sd"> :rtype: stack</span>
<span class="sd"> &#39;&#39;&#39;</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"># 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="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"># 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"># In-lining is slightly faster (and won&#39;t break the</span>
<span class="c1"># recursion limit on long quotes.)</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">## temp = []</span>
<span class="c1">## while quote:</span>
@ -208,27 +207,27 @@
<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">s</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return the nth item on the stack.</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"> Return the nth item on the stack.</span>
<span class="sd"> :param stack s: A 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 IndexError: if ``n`` is equal to or greater than the length of ``s``.</span>
<span class="sd"> :rtype: whatever</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">raise</span> <span class="ne">ValueError</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">item</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">s</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="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="k">return</span> <span class="n">item</span></div>
<span class="sd"> :param stack stack: A 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 IndexError: if ``n`` is equal to or greater than the length of ``stack``.</span>
<span class="sd"> :rtype: whatever</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">raise</span> <span class="ne">ValueError</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">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">raise</span> <span class="ne">IndexError</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="k">return</span> <span class="n">item</span></div>
</pre></div>
</div>

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

@ -58,6 +58,7 @@
| <a href="#V"><strong>V</strong></a>
| <a href="#W"><strong>W</strong></a>
| <a href="#X"><strong>X</strong></a>
| <a href="#Y"><strong>Y</strong></a>
| <a href="#Z"><strong>Z</strong></a>
</div>
@ -72,6 +73,8 @@
<li><a href="types.html#joy.utils.types.IntJoyType.accept">(joy.utils.types.IntJoyType attribute)</a>
</li>
<li><a href="types.html#joy.utils.types.StackJoyType.accept">(joy.utils.types.StackJoyType attribute)</a>
</li>
<li><a href="types.html#joy.utils.types.TextJoyType.accept">(joy.utils.types.TextJoyType attribute)</a>
</li>
</ul></li>
<li><a href="library.html#joy.library.add_aliases">add_aliases() (in module joy.library)</a>
@ -120,7 +123,7 @@
</li>
<li><a href="library.html#joy.library.cmp_">cmp_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.CombinatorJoyType">CombinatorJoyType (class in joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.CombinatorJoyType">CombinatorJoyType (class in joy.utils.types)</a>
</li>
<li><a href="types.html#joy.utils.types.compilable">compilable() (in module joy.utils.types)</a>
</li>
@ -128,12 +131,8 @@
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.compile_">compile_() (in module joy.utils.types)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.compose">compose() (in module joy.utils.polytypes)</a>
<ul>
<li><a href="types.html#joy.utils.types.compose">(in module joy.utils.types)</a>
<li><a href="types.html#joy.utils.types.compose">compose() (in module joy.utils.types)</a>
</li>
</ul></li>
<li><a href="stack.html#joy.utils.stack.concat">concat() (in module joy.utils.stack)</a>
</li>
<li><a href="library.html#joy.library.concat_">concat_() (in module joy.library)</a>
@ -150,12 +149,6 @@
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.DefinitionWrapper">DefinitionWrapper (class in joy.library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.defs">defs() (in module joy.utils.polytypes)</a>
<ul>
<li><a href="types.html#joy.utils.types.defs">(in module joy.utils.types)</a>
</li>
</ul></li>
<li><a href="types.html#joy.utils.types.delabel">delabel() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.dip">dip() (in module joy.library)</a>
@ -164,10 +157,10 @@
</li>
<li><a href="library.html#joy.library.dipdd">dipdd() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.divmod_">divmod_() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.types.doc_from_stack_effect">doc_from_stack_effect() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.drop">drop() (in module joy.library)</a>
@ -199,16 +192,14 @@
<li><a href="library.html#joy.utils.generated_library.first_two">first_two() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.FloatJoyType">FloatJoyType (class in joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.floor">floor() (in module joy.library)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.floor">floor() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.fourth">fourth() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.FunctionJoyType">FunctionJoyType (class in joy.utils.polytypes)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.FUNCTIONS">FUNCTIONS (in module joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.FunctionJoyType">FunctionJoyType (class in joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.FunctionWrapper">FunctionWrapper() (in module joy.library)</a>
</li>
@ -244,7 +235,9 @@
</li>
<li><a href="library.html#joy.library.id_">id_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.infer">infer() (in module joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.infer">infer() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.infer_">infer_() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.library.infra">infra() (in module joy.library)</a>
</li>
@ -254,12 +247,10 @@
</li>
<li><a href="library.html#joy.library.inscribe">inscribe() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.IntJoyType">IntJoyType (class in joy.utils.polytypes)</a>
<ul>
<li><a href="types.html#joy.utils.types.IntJoyType">(class in joy.utils.types)</a>
<li><a href="library.html#joy.library.inscribe_">inscribe_() (in module joy.library)</a>
</li>
<li><a href="types.html#joy.utils.types.IntJoyType">IntJoyType (class in joy.utils.types)</a>
</li>
</ul></li>
<li><a href="stack.html#joy.utils.stack.iter_stack">iter_stack() (in module joy.utils.stack)</a>
</li>
</ul></td>
@ -275,12 +266,10 @@
<li><a href="library.html#module-joy.library">joy.library (module)</a>
</li>
<li><a href="parser.html#module-joy.parser">joy.parser (module)</a>
</li>
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#module-joy.utils.polytypes">joy.utils.polytypes (module)</a>
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a>
</li>
<li><a href="pretty.html#module-joy.utils.pretty_print">joy.utils.pretty_print (module)</a>
</li>
@ -296,11 +285,11 @@
<h2 id="K">K</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.polytypes.KleeneStar.kind">kind (joy.utils.polytypes.KleeneStar attribute)</a>
<li><a href="types.html#joy.utils.types.KleeneStar.kind">kind (joy.utils.types.KleeneStar attribute)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.polytypes.KleeneStar">KleeneStar (class in joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.KleeneStar">KleeneStar (class in joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@ -326,7 +315,7 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="types.html#joy.utils.polytypes.meta_compose">meta_compose() (in module joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.meta_compose">meta_compose() (in module joy.utils.types)</a>
</li>
<li><a href="library.html#joy.library.min_">min_() (in module joy.library)</a>
</li>
@ -362,10 +351,12 @@
</li>
<li><a href="library.html#joy.library.pm">pm() (in module joy.library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.pop">pop() (in module joy.utils.generated_library)</a>
<li><a href="types.html#joy.utils.types.poly_compose">poly_compose() (in module joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.utils.generated_library.pop">pop() (in module joy.utils.generated_library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.popd">popd() (in module joy.utils.generated_library)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.popdd">popdd() (in module joy.utils.generated_library)</a>
@ -452,7 +443,7 @@
</li>
<li><a href="parser.html#joy.parser.Symbol">Symbol (class in joy.parser)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.SymbolJoyType">SymbolJoyType (class in joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.SymbolJoyType">SymbolJoyType (class in joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@ -463,6 +454,8 @@
<li><a href="library.html#joy.library.take">take() (in module joy.library)</a>
</li>
<li><a href="parser.html#joy.parser.text_to_expression">text_to_expression() (in module joy.parser)</a>
</li>
<li><a href="types.html#joy.utils.types.TextJoyType">TextJoyType (class in joy.utils.types)</a>
</li>
<li><a href="library.html#joy.utils.generated_library.third">third() (in module joy.utils.generated_library)</a>
</li>
@ -474,7 +467,7 @@
</li>
<li><a href="library.html#joy.utils.generated_library.tuck">tuck() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.polytypes.type_check">type_check() (in module joy.utils.polytypes)</a>
<li><a href="types.html#joy.utils.types.type_check">type_check() (in module joy.utils.types)</a>
</li>
</ul></td>
</tr></table>
@ -486,7 +479,7 @@
</li>
<li><a href="library.html#joy.utils.generated_library.uncons">uncons() (in module joy.utils.generated_library)</a>
</li>
<li><a href="types.html#joy.utils.types.unify">unify() (in module joy.utils.types)</a>
<li><a href="types.html#joy.utils.types.uni_unify">uni_unify() (in module joy.utils.types)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
@ -533,6 +526,14 @@
</ul></td>
</tr></table>
<h2 id="Y">Y</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="library.html#joy.library.yin_functions">yin_functions() (in module joy.library)</a>
</li>
</ul></td>
</tr></table>
<h2 id="Z">Z</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>

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

@ -42,11 +42,13 @@ match the behaviour of the original version(s) written in C.</p>
<dl class="function">
<dt id="joy.joy.joy">
<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>
<dd><p>Evaluate the Joy expression on the stack.</p>
<p>The basic joy() function is quite straightforward. It iterates through a
sequence of terms which are either literals (strings, numbers, sequences)
or functions. Literals are put onto the stack and functions are
executed.</p>
<dd><p>Evaluate a Joy expression on a stack.</p>
<p>This function iterates through a sequence of terms which are either
literals (strings, numbers, sequences of terms) or function symbols.
Literals are put onto the stack and functions are looked up in the
disctionary and executed.</p>
<p>The viewer is a function that is called with the stack and expression
on every iteration, its return value is ignored.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />

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

@ -52,7 +52,7 @@ function.</p>
<dd><p>Provide implementation of defined functions, and some helper methods.</p>
<dl class="classmethod">
<dt id="joy.library.DefinitionWrapper.add_def">
<em class="property">classmethod </em><code class="descname">add_def</code><span class="sig-paren">(</span><em>definition</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#DefinitionWrapper.add_def"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.DefinitionWrapper.add_def" title="Permalink to this definition"></a></dt>
<em class="property">classmethod </em><code class="descname">add_def</code><span class="sig-paren">(</span><em>definition</em>, <em>dictionary</em>, <em>fail_fails=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#DefinitionWrapper.add_def"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.DefinitionWrapper.add_def" title="Permalink to this definition"></a></dt>
<dd><p>Add the definition to the dictionary.</p>
</dd></dl>
@ -104,9 +104,9 @@ if it’s in the dict. Aliases for functions not in the dict are ignored.</p>
<dd><p>Given a quoted program on TOS and anything as the second stack item run
the program and replace the two args with the first result of the
program.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@ -115,10 +115,10 @@ program.</p>
<dt id="joy.library.app2">
<code class="descclassname">joy.library.</code><code class="descname">app2</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app2"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app2" title="Permalink to this definition"></a></dt>
<dd><p>Like app1 with two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@ -127,11 +127,11 @@ program.</p>
<dt id="joy.library.app3">
<code class="descclassname">joy.library.</code><code class="descname">app3</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app3"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app3" title="Permalink to this definition"></a></dt>
<dd><p>Like app1 with three items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
<span class="o">-----------------------------------</span>
<span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
<span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">infra</span> <span class="n">first</span>
</pre></div>
</div>
</dd></dl>
@ -154,13 +154,13 @@ program.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">branch</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="n">choice</span> <span class="n">i</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="o">--------------------------</span>
<span class="n">F</span>
<span class="n">F</span>
<span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
<span class="o">-------------------------</span>
<span class="n">T</span>
<span class="n">T</span>
</pre></div>
</div>
</dd></dl>
@ -169,14 +169,14 @@ program.</p>
<dt id="joy.library.choice">
<code class="descclassname">joy.library.</code><code class="descname">choice</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#choice"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.choice" title="Permalink to this definition"></a></dt>
<dd><p>Use a Boolean value to select one of two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
<span class="o">----------------------</span>
<span class="n">A</span>
<span class="n">A</span>
<span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
<span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
<span class="o">---------------------</span>
<span class="n">B</span>
<span class="n">B</span>
</pre></div>
</div>
<p>Currently Python semantics are used to evaluate the “truthiness” of the
@ -189,7 +189,7 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<dd><p>Clear everything from the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">clear</span> <span class="o">==</span> <span class="n">stack</span> <span class="p">[</span><span class="n">pop</span> <span class="n">stack</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="n">clear</span>
<span class="o">...</span> <span class="n">clear</span>
<span class="o">---------------</span>
</pre></div>
</div>
@ -200,17 +200,17 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<code class="descclassname">joy.library.</code><code class="descname">cmp_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cmp_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cmp_" title="Permalink to this definition"></a></dt>
<dd><p>cmp takes two values and three quoted programs on the stack and runs
one of the three depending on the results of comparing the two values:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span>
<span class="n">G</span>
<span class="n">G</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
<span class="n">E</span>
<span class="n">E</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span>
<span class="n">L</span>
<span class="n">L</span>
</pre></div>
</div>
</dd></dl>
@ -219,9 +219,9 @@ one of the three depending on the results of comparing the two values:</p>
<dt id="joy.library.concat_">
<code class="descclassname">joy.library.</code><code class="descname">concat_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#concat_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.concat_" title="Permalink to this definition"></a></dt>
<dd><p>Concatinate the two lists on the top of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
<span class="o">----------------------------</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@ -235,9 +235,9 @@ default quote. Each condition clause should contain a quoted predicate
followed by the function expression to run if that predicate returns
true. If no predicates return true the default function runs.</p>
<p>It works by rewriting into a chain of nested <cite>ifte</cite> expressions, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
<span class="o">-----------------------------------------</span>
<span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
<span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div>
</div>
</dd></dl>
@ -248,9 +248,9 @@ true. If no predicates return true the default function runs.</p>
<dd><p>The dip combinator expects a quoted program on the stack and below it
some item, it hoists the item into the expression and runs the program
on the rest of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">-------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@ -259,9 +259,9 @@ on the rest of the stack.</p>
<dt id="joy.library.dipd">
<code class="descclassname">joy.library.</code><code class="descname">dipd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipd" title="Permalink to this definition"></a></dt>
<dd><p>Like dip but expects two items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">---------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@ -270,9 +270,9 @@ on the rest of the stack.</p>
<dt id="joy.library.dipdd">
<code class="descclassname">joy.library.</code><code class="descname">dipdd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipdd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipdd" title="Permalink to this definition"></a></dt>
<dd><p>Like dip but expects three items.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
<span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
</pre></div>
</div>
</dd></dl>
@ -287,14 +287,20 @@ on the rest of the stack.</p>
<dl class="function">
<dt id="joy.library.drop">
<code class="descclassname">joy.library.</code><code class="descname">drop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#drop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.drop" title="Permalink to this definition"></a></dt>
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
<dd><blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
</pre></div>
</div>
<p>Expects an integer and a quote on the stack and returns the quote with
n items removed off the top.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">drop</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">drop</span>
<span class="o">----------------------</span>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
@ -323,9 +329,9 @@ This is the largest integral value &lt;= x.</p>
<dt id="joy.library.genrec">
<code class="descclassname">joy.library.</code><code class="descname">genrec</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#genrec"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.genrec" title="Permalink to this definition"></a></dt>
<dd><p>General Recursion Combinator.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span>
<span class="o">---------------------------------------------------------------------</span>
<span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span> <span class="p">[[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="n">rec2</span><span class="p">]</span> <span class="n">ifte</span>
<span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span> <span class="p">[[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="n">rec2</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div>
</div>
<p>From “Recursion Theory and Joy” (j05cmp.html) by Manfred von Thun:
@ -355,13 +361,13 @@ have to do to apply the quoted [F] in the proper way. In effect, the
genrec combinator turns into an ifte combinator with a quoted copy of
the original definition in the else-part:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</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">R1</span><span class="p">]</span> <span class="p">[</span><span class="n">R2</span><span class="p">]</span> <span class="n">genrec</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">R1</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">R2</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">R1</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">R2</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div>
</div>
<p>Primitive recursive functions are those where R2 == i.</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>
<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">P</span><span class="p">]</span> <span class="n">i</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>
<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">P</span><span class="p">]</span> <span class="n">i</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>
</div>
</dd></dl>
@ -369,14 +375,20 @@ the original definition in the else-part:</p>
<dl class="function">
<dt id="joy.library.getitem">
<code class="descclassname">joy.library.</code><code class="descname">getitem</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#getitem"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.getitem" title="Permalink to this definition"></a></dt>
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
<dd><blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
</pre></div>
</div>
<p>Expects an integer and a quote on the stack and returns the item at the
nth position in the quote counting from 0.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">0</span> <span class="n">getitem</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">0</span> <span class="n">getitem</span>
<span class="o">-------------------------</span>
<span class="n">a</span>
<span class="n">a</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="n">a1</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
@ -392,9 +404,9 @@ nth position in the quote counting from 0.</p>
<code class="descclassname">joy.library.</code><code class="descname">i</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#i"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.i" title="Permalink to this definition"></a></dt>
<dd><p>The i combinator expects a quoted program on the stack and unpacks it
onto the pending expression for evaluation.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
<span class="o">-----------</span>
<span class="n">Q</span>
<span class="n">Q</span>
</pre></div>
</div>
</dd></dl>
@ -405,14 +417,20 @@ onto the pending expression for evaluation.</p>
<dd><p>The identity function.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.infer_">
<code class="descclassname">joy.library.</code><code class="descname">infer_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infer_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infer_" title="Permalink to this definition"></a></dt>
<dd><p>Attempt to infer the stack effect of a Joy expression.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.infra">
<code class="descclassname">joy.library.</code><code class="descname">infra</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infra"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infra" title="Permalink to this definition"></a></dt>
<dd><p>Accept a quoted program and a list on the stack and run the program
with the list as its stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
with the list as its stack. Does not affect the rest of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
<span class="o">-----------------------------</span>
<span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
<span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
</pre></div>
</div>
</dd></dl>
@ -429,17 +447,35 @@ with the list as its stack.</p>
<dd><p>A decorator to inscribe functions into the default dictionary.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.inscribe_">
<code class="descclassname">joy.library.</code><code class="descname">inscribe_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#inscribe_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.inscribe_" title="Permalink to this definition"></a></dt>
<dd><blockquote>
<div><p>Create a new Joy function definition in the Joy dictionary. A
definition is given as a string with a name followed by a double
equal sign then one or more Joy functions, the body. for example:</p>
<blockquote>
<div>sqr == dup mul</div></blockquote>
<p>If you want the definition to persist over restarts, enter it into
the definitions.txt resource.</p>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">t1</span> <span class="o">--</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.loop">
<code class="descclassname">joy.library.</code><code class="descname">loop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#loop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.loop" title="Permalink to this definition"></a></dt>
<dd><p>Basic loop combinator.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
<span class="o">------------------------</span>
<span class="o">...</span>
<span class="o">...</span>
</pre></div>
</div>
</dd></dl>
@ -448,19 +484,27 @@ with the list as its stack.</p>
<dt id="joy.library.map_">
<code class="descclassname">joy.library.</code><code class="descname">map_</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#map_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.map_" title="Permalink to this definition"></a></dt>
<dd><p>Run the quoted program on TOS on the items in the list under it, push a
new list with the results (in place of the program and original list.</p>
new list with the results in place of the program and original list.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.max_">
<code class="descclassname">joy.library.</code><code class="descname">max_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#max_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.max_" title="Permalink to this definition"></a></dt>
<dd><p>Given a list find the maximum.</p>
<dd><p>Given a list find the maximum.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.min_">
<code class="descclassname">joy.library.</code><code class="descname">min_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#min_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.min_" title="Permalink to this definition"></a></dt>
<dd><p>Given a list find the minimum.</p>
<dd><p>Given a list find the minimum.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@ -473,9 +517,9 @@ new list with the results (in place of the program and original list.</p>
<dt id="joy.library.pm">
<code class="descclassname">joy.library.</code><code class="descname">pm</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pm" title="Permalink to this definition"></a></dt>
<dd><p>Plus or minus</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
<span class="o">-------------</span>
<span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
<span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
</pre></div>
</div>
</dd></dl>
@ -483,7 +527,11 @@ new list with the results (in place of the program and original list.</p>
<dl class="function">
<dt id="joy.library.pred">
<code class="descclassname">joy.library.</code><code class="descname">pred</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pred"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pred" title="Permalink to this definition"></a></dt>
<dd><p>Decrement TOS.</p>
<dd><p>Decrement TOS.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@ -491,9 +539,9 @@ new list with the results (in place of the program and original list.</p>
<code class="descclassname">joy.library.</code><code class="descname">remove</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#remove"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.remove" title="Permalink to this definition"></a></dt>
<dd><p>Expects an item on the stack and a quote under it and removes that item
from the the quote. The item is only removed once.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
<span class="o">------------------------</span>
<span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@ -511,14 +559,14 @@ from the the quote. The item is only removed once.</p>
<dt id="joy.library.select">
<code class="descclassname">joy.library.</code><code class="descname">select</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#select"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.select" title="Permalink to this definition"></a></dt>
<dd><p>Use a Boolean value to select one of two items from a sequence.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">False</span> <span class="n">select</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">False</span> <span class="n">select</span>
<span class="o">------------------------</span>
<span class="n">A</span>
<span class="n">A</span>
<span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
<span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
<span class="o">-----------------------</span>
<span class="n">B</span>
<span class="n">B</span>
</pre></div>
</div>
<p>The sequence can contain more than two items but not fewer.
@ -538,9 +586,9 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<dd><p>Like concat but reverses the top list into the second.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">shunt</span> <span class="o">==</span> <span class="p">[</span><span class="n">swons</span><span class="p">]</span> <span class="n">step</span> <span class="o">==</span> <span class="n">reverse</span> <span class="n">swap</span> <span class="n">concat</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
<span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
<span class="o">---------------------------</span>
<span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span>
<span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span>
</pre></div>
</div>
</dd></dl>
@ -562,19 +610,19 @@ Negative numbers return complex roots.</p>
<dt id="joy.library.step">
<code class="descclassname">joy.library.</code><code class="descname">step</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#step"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.step" title="Permalink to this definition"></a></dt>
<dd><p>Run a quoted program on each item in a sequence.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="o">.</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">-----------------------</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
<span class="o">----------------------------------------</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
<span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
</pre></div>
</div>
<p>The step combinator executes the quotation on each member of the list
@ -584,25 +632,40 @@ on top of the stack.</p>
<dl class="function">
<dt id="joy.library.succ">
<code class="descclassname">joy.library.</code><code class="descname">succ</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#succ"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.succ" title="Permalink to this definition"></a></dt>
<dd><p>Increment TOS.</p>
<dd><p>Increment TOS.
Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.sum_">
<code class="descclassname">joy.library.</code><code class="descname">sum_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#sum_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.sum_" title="Permalink to this definition"></a></dt>
<dd><p>Given a quoted sequence of numbers return the sum.</p>
<p>sum == 0 swap [+] step</p>
<blockquote>
<div>sum == 0 swap [+] step</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.take">
<code class="descclassname">joy.library.</code><code class="descname">take</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#take"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.take" title="Permalink to this definition"></a></dt>
<dd><p>Expects an integer and a quote on the stack and returns the quote with
<dd><blockquote>
<div><p>Expects an integer and a quote on the stack and returns the quote with
just the top n items in reverse order (because that’s easier and you can
use reverse if needed.)</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
<span class="o">----------------------</span>
<span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
<span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
</pre></div>
</div>
</div></blockquote>
<p>Stack effect:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
@ -611,19 +674,19 @@ use reverse if needed.)</p>
<dt id="joy.library.times">
<code class="descclassname">joy.library.</code><code class="descname">times</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#times"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.times" title="Permalink to this definition"></a></dt>
<dd><p>times == [– dip] cons [swap] infra [0 &gt;] swap while pop</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">0</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="o">.</span>
<span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------------------</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>
<span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
<span class="o">---------------------------------</span> <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">1</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
<span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
</pre></div>
</div>
</dd></dl>
@ -671,6 +734,15 @@ the stack discarding the rest of the stack.</p>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.library.yin_functions">
<code class="descclassname">joy.library.</code><code class="descname">yin_functions</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#yin_functions"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.yin_functions" title="Permalink to this definition"></a></dt>
<dd><p>Return a dict of named stack effects.</p>
<p>“Yin” functions are those that only rearrange items in stacks and
can be defined completely by their stack effects. This means they
can be auto-compiled.</p>
</dd></dl>
<dl class="function">
<dt id="joy.library.zip_">
<code class="descclassname">joy.library.</code><code class="descname">zip_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#zip_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.zip_" title="Permalink to this definition"></a></dt>

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

@ -498,8 +498,9 @@ machine transition table.</p>
</pre></div>
</div>
<p>Says, “Three or more 1’s and not ending in 01 nor composed of all 1’s.”</p>
<div class="figure">
<img alt="State Machine Diagram" src="../_images/omg.svg" /></div>
<div class="figure" id="id2">
<img alt="omg.svg" src="../_images/omg.svg" /><p class="caption"><span class="caption-text">omg.svg</span></p>
</div>
<p>Start at <code class="docutils literal notranslate"><span class="pre">a</span></code> and follow the transition arrows according to their
labels. Accepting states have a double outline. (Graphic generated with
<a class="reference external" href="http://www.graphviz.org/">Dot from Graphviz</a>.) You’ll see that only

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

Binary file not shown.

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

@ -43,10 +43,14 @@ expression as well as a single Symbol class and a single Exception type.</p>
by the fact that they are not Symbol objects.</p>
<p>A crude grammar:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span>
<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">function</span>
<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">symbol</span>
</pre></div>
</div>
<p>A Joy expression is a sequence of zero or more terms</p>
<p>A Joy expression is a sequence of zero or more terms. A term is a
literal value (integer, float, string, or Joy expression) or a function
symbol. Function symbols are unquoted strings and cannot contain square
brackets. Terms must be separated by blanks, which can be omitted
around square brackets.</p>
<dl class="exception">
<dt 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>

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

@ -70,11 +70,6 @@
<td>&#160;&#160;&#160;
<a href="library.html#module-joy.utils.generated_library"><code class="xref">joy.utils.generated_library</code></a></td><td>
<em></em></td></tr>
<tr class="cg-1">
<td></td>
<td>&#160;&#160;&#160;
<a href="types.html#module-joy.utils.polytypes"><code class="xref">joy.utils.polytypes</code></a></td><td>
<em></em></td></tr>
<tr class="cg-1">
<td></td>
<td>&#160;&#160;&#160;

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

File diff suppressed because one or more lines are too long

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

@ -59,7 +59,7 @@ 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>
<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>
<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>
</div>
<p>We replace the argument “stack” by the expected structure of the stack,
@ -71,8 +71,8 @@ where they would be redundant.)</p>
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>
<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="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="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>
</pre></div>
</div>
<p>We have two very simple functions, one to build up a stack from a Python
@ -168,21 +168,21 @@ won’t work because <code class="docutils literal notranslate"><span class="pre
<dl class="function">
<dt id="joy.utils.stack.pick">
<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>s</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>
<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>
<dd><p>Return the nth item on the stack.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>s</strong> (<em>stack</em>) – A stack.</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>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><ul class="first simple">
<li><strong>ValueError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is less than zero.</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">s</span></code>.</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>
</ul>
</td>
</tr>

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

@ -117,6 +117,18 @@
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.CombinatorJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.CombinatorJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent combinators.</p>
<p>These type variables carry Joy functions that implement the
behaviour of Joy combinators and they can appear in expressions.
For simple combinators the implementation functions can be the
combinators themselves.</p>
<p>These types can also specify a stack effect (input side only) to
guard against being used on invalid types.</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.FloatJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FloatJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FloatJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FloatJoyType" title="Permalink to this definition"></a></dt>
@ -128,6 +140,11 @@
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.FunctionJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FunctionJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FunctionJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FunctionJoyType" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.types.IntJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">IntJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#IntJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.IntJoyType" title="Permalink to this definition"></a></dt>
@ -144,6 +161,29 @@
<em class="property">exception </em><code class="descclassname">joy.utils.types.</code><code class="descname">JoyTypeError</code><a class="reference internal" href="_modules/joy/utils/types.html#JoyTypeError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.JoyTypeError" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.types.KleeneStar">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">KleeneStar</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#KleeneStar"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.KleeneStar" title="Permalink to this definition"></a></dt>
<dd><p>A sequence of zero or more <cite>AnyJoyType</cite> variables would be:</p>
<blockquote>
<div>A*</div></blockquote>
<p>The <cite>A*</cite> works by splitting the universe into two alternate histories:</p>
<blockquote>
<div><p>A* → ∅</p>
<p>A* → A A*</p>
</div></blockquote>
<p>The Kleene star variable disappears in one universe, and in the other
it turns into an <cite>AnyJoyType</cite> variable followed by itself again.</p>
<p>We have to return all universes (represented by their substitution
dicts, the “unifiers”) that don’t lead to type conflicts.</p>
<dl class="attribute">
<dt id="joy.utils.types.KleeneStar.kind">
<code class="descname">kind</code><a class="headerlink" href="#joy.utils.types.KleeneStar.kind" title="Permalink to this definition"></a></dt>
<dd><p>alias of <a class="reference internal" href="#joy.utils.types.AnyJoyType" title="joy.utils.types.AnyJoyType"><code class="xref py py-class docutils literal notranslate"><span class="pre">AnyJoyType</span></code></a></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.NumberJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">NumberJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#NumberJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.NumberJoyType" title="Permalink to this definition"></a></dt>
@ -160,6 +200,25 @@
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.SymbolJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">SymbolJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#SymbolJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.SymbolJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent non-combinator functions.</p>
<p>These type variables carry the stack effect comments and can
appear in expressions (as in quoted programs.)</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.types.TextJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">TextJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#TextJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.TextJoyType" title="Permalink to this definition"></a></dt>
<dd><dl class="attribute">
<dt id="joy.utils.types.TextJoyType.accept">
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.TextJoyType.accept" title="Permalink to this definition"></a></dt>
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.basestring</span></code></p>
</dd></dl>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.compilable">
<code class="descclassname">joy.utils.types.</code><code class="descname">compilable</code><span class="sig-paren">(</span><em>f</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compilable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compilable" title="Permalink to this definition"></a></dt>
@ -181,12 +240,6 @@ is used to generate one.</p>
<dd><p>Return the stack effect of the composition of some of stack effects.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.defs">
<code class="descclassname">joy.utils.types.</code><code class="descname">defs</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#defs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.defs" title="Permalink to this definition"></a></dt>
<dd><p>Return a dict of named stack effects.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.delabel">
<code class="descclassname">joy.utils.types.</code><code class="descname">delabel</code><span class="sig-paren">(</span><em>f</em>, <em>seen=None</em>, <em>c=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#delabel"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.delabel" title="Permalink to this definition"></a></dt>
@ -195,10 +248,40 @@ is used to generate one.</p>
<dl class="function">
<dt id="joy.utils.types.doc_from_stack_effect">
<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition"></a></dt>
<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs=('??'</em>, <em>())</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition"></a></dt>
<dd><p>Return a crude string representation of a stack effect.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.infer">
<code class="descclassname">joy.utils.types.</code><code class="descname">infer</code><span class="sig-paren">(</span><em>*expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#infer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.infer" title="Permalink to this definition"></a></dt>
<dd><p>Return a list of stack effects for a Joy expression.</p>
<p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">h</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">h</span><span class="p">:</span>
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span>
</pre></div>
</div>
<p>Prints:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.meta_compose">
<code class="descclassname">joy.utils.types.</code><code class="descname">meta_compose</code><span class="sig-paren">(</span><em>F</em>, <em>G</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#meta_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.meta_compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two lists of stack
effects. An expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.poly_compose">
<code class="descclassname">joy.utils.types.</code><code class="descname">poly_compose</code><span class="sig-paren">(</span><em>f</em>, <em>g</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#poly_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.poly_compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two stack effects. An
expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.reify">
<code class="descclassname">joy.utils.types.</code><code class="descname">reify</code><span class="sig-paren">(</span><em>meaning</em>, <em>name</em>, <em>seen=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#reify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.reify" title="Permalink to this definition"></a></dt>
@ -212,8 +295,16 @@ is used to generate one.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.unify">
<code class="descclassname">joy.utils.types.</code><code class="descname">unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.unify" title="Permalink to this definition"></a></dt>
<dt id="joy.utils.types.type_check">
<code class="descclassname">joy.utils.types.</code><code class="descname">type_check</code><span class="sig-paren">(</span><em>name</em>, <em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#type_check"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.type_check" title="Permalink to this definition"></a></dt>
<dd><p>Trinary predicate. True if named function type-checks, False if it
fails, None if it’s indeterminate (because I haven’t entered it into
the FUNCTIONS dict yet.)</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.types.uni_unify">
<code class="descclassname">joy.utils.types.</code><code class="descname">uni_unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#uni_unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.uni_unify" title="Permalink to this definition"></a></dt>
<dd><p>Return a substitution dict representing a unifier for u and v.</p>
</dd></dl>
@ -272,114 +363,6 @@ is used to generate one.</p>
(i2 i1 -- i3)
</pre></div>
</div>
<span class="target" id="module-joy.utils.polytypes"></span><p>Multiple Stack Effects</p>
<p>By adjusting the machinery in types.py to handles lists of stack effect comments
we can capture more information about the type signatures of some functions,
and we can introduce a kind of Kleene Star or sequence type that can stand for
an unbounded sequence of other types.</p>
<dl class="class">
<dt id="joy.utils.polytypes.CombinatorJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.CombinatorJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent combinators.</p>
<p>These type variables carry Joy functions that implement the
behaviour of Joy combinators and they can appear in expressions.
For simple combinators the implementation functions can be the
combinators themselves.</p>
<p>These types can also specify a stack effect (input side only) to
guard against being used on invalid types.</p>
</dd></dl>
<dl class="data">
<dt id="joy.utils.polytypes.FUNCTIONS">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">FUNCTIONS</code><em class="property"> = {'!=': ne, '&amp;': and, '*': mul, '+': add, '++': succ, '-': sub, '--': pred, '/': truediv, '&lt;': lt, '&lt;&lt;': lshift, '&lt;=': le, '&lt;&gt;': ne, '=': eq, '&gt;': gt, '&gt;=': ge, '&gt;&gt;': rshift, '_Tree_add_Ee': _Tree_add_Ee, '_Tree_delete_R0': _Tree_delete_R0, '_Tree_delete_clear_stuff': _Tree_delete_clear_stuff, '_Tree_get_E': _Tree_get_E, 'add': add, 'and': and, 'b': b, 'bool': bool, 'branch': branch, 'ccons': ccons, 'clear': clear, 'concat_': concat_, 'cons': cons, 'dip': dip, 'dipd': dipd, 'dipdd': dipdd, 'div': div, 'divmod': divmod, 'dup': dup, 'dupd': dupd, 'dupdd': dupdd, 'dupdip': dupdip, 'eq': eq, 'first': first, 'first_two': first_two, 'floordiv': floordiv, 'fourth': fourth, 'ge': ge, 'gt': gt, 'i': i, 'infra': infra, 'le': le, 'loop': loop, 'lshift': lshift, 'lt': lt, 'modulus': modulus, 'mul': mul, 'ne': ne, 'neg': neg, 'not': not, 'nullary': nullary, 'over': over, 'pop': pop, 'popd': popd, 'popdd': popdd, 'popop': popop, 'popopd': popopd, 'popopdd': popopdd, 'pow': pow, 'pred': pred, 'product': product, 'rest': rest, 'roll&lt;': rolldown, 'roll&gt;': rollup, 'rolldown': rolldown, 'rollup': rollup, 'rrest': rrest, 'rshift': rshift, 'second': second, 'sqrt': sqrt, 'stack': stack, 'stuncons': stuncons, 'stununcons': stununcons, 'sub': sub, 'succ': succ, 'sum': sum, 'swaack': swaack, 'swap': swap, 'swons': swons, 'third': third, 'truediv': truediv, 'truthy': bool, 'tuck': tuck, 'uncons': uncons, 'unit': unit, 'unswons': unswons, 'x': x}</em><a class="headerlink" href="#joy.utils.polytypes.FUNCTIONS" title="Permalink to this definition"></a></dt>
<dd><p>Docstring for functions in Sphinx?</p>
</dd></dl>
<dl class="class">
<dt id="joy.utils.polytypes.FunctionJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">FunctionJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#FunctionJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.FunctionJoyType" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.polytypes.IntJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">IntJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#IntJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.IntJoyType" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="class">
<dt id="joy.utils.polytypes.KleeneStar">
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">KleeneStar</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#KleeneStar"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.KleeneStar" title="Permalink to this definition"></a></dt>
<dd><p>A sequence of zero or more <cite>AnyJoyType</cite> variables would be:</p>
<blockquote>
<div>A*</div></blockquote>
<p>The <cite>A*</cite> works by splitting the universe into two alternate histories:</p>
<blockquote>
<div><p>A* → ∅</p>
<p>A* → A A*</p>
</div></blockquote>
<p>The Kleene star variable disappears in one universe, and in the other
it turns into an <cite>AnyJoyType</cite> variable followed by itself again.</p>
<p>We have to return all universes (represented by their substitution
dicts, the “unifiers”) that don’t lead to type conflicts.</p>
<dl class="attribute">
<dt id="joy.utils.polytypes.KleeneStar.kind">
<code class="descname">kind</code><a class="headerlink" href="#joy.utils.polytypes.KleeneStar.kind" title="Permalink to this definition"></a></dt>
<dd><p>alias of <a class="reference internal" href="#joy.utils.types.AnyJoyType" title="joy.utils.types.AnyJoyType"><code class="xref py py-class docutils literal notranslate"><span class="pre">joy.utils.types.AnyJoyType</span></code></a></p>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="joy.utils.polytypes.SymbolJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">SymbolJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#SymbolJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.SymbolJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent non-combinator functions.</p>
<p>These type variables carry the stack effect comments and can
appear in expressions (as in quoted programs.)</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.polytypes.compose">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">compose</code><span class="sig-paren">(</span><em>f</em>, <em>g</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two stack effects. An
expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.polytypes.defs">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">defs</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#defs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.defs" title="Permalink to this definition"></a></dt>
<dd><p>Return a dict of FunctionJoyType instances to be used with <code class="docutils literal notranslate"><span class="pre">infer()</span></code>.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.polytypes.infer">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">infer</code><span class="sig-paren">(</span><em>*expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#infer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.infer" title="Permalink to this definition"></a></dt>
<dd><p>Return a list of stack effects for a Joy expression.</p>
<p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">h</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">h</span><span class="p">:</span>
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span>
</pre></div>
</div>
<p>Prints:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="joy.utils.polytypes.meta_compose">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">meta_compose</code><span class="sig-paren">(</span><em>F</em>, <em>G</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#meta_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.meta_compose" title="Permalink to this definition"></a></dt>
<dd><p>Yield the stack effects of the composition of two lists of stack
effects. An expression is carried along and updated and yielded.</p>
</dd></dl>
<dl class="function">
<dt id="joy.utils.polytypes.type_check">
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">type_check</code><span class="sig-paren">(</span><em>name</em>, <em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#type_check"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.type_check" title="Permalink to this definition"></a></dt>
<dd><p>Trinary predicate. True if named function type-checks, False if it
fails, None if it’s indeterminate (because I haven’t entered it into
the FUNCTIONS dict yet.)</p>
</dd></dl>
</div>
</div>