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

214
docs/0._This_Implementation_of_Joy_in_Python.ipynb
View File

@ -67,17 +67,19 @@
"name": "stdout", "name": "stdout",
"output_type": "stream", "output_type": "stream",
"text": [ "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", "\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", "\n",
"When talking about Joy we use the terms \"stack\", \"list\", \"sequence\" and\n", " stack := () | (item, stack)\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",
"\n", "\n",
"We use the venerable two-tuple recursive form of sequences where the\n", "Putting some numbers onto a stack::\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", "\n",
" ()\n", " ()\n",
" (1, ())\n", " (1, ())\n",
@ -85,39 +87,36 @@
" (3, (2, (1, ())))\n", " (3, (2, (1, ())))\n",
" ...\n", " ...\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",
"Python has very nice \"tuple packing and unpacking\" in its syntax which\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", "means we can directly \"unpack\" the expected arguments to a Joy function.\n",
"\n", "\n",
"For example:\n", "For example::\n",
"\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 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",
"\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", "\n",
" def dup(stack):\n", " def dup(stack):\n",
" head, tail = stack\n", " head, tail = stack\n",
" return head, (head, tail)\n", " return head, (head, tail)\n",
"\n", "\n",
"We replace the argument \"stack\" by the expected structure of the stack,\n", "\n",
"in this case \"(head, tail)\", and Python takes care of de-structuring the\n", "We have two very simple functions, one to build up a stack from a Python\n",
"incoming argument and assigning values to the names. Note that Python\n", "iterable and another to iterate through a stack and yield its items\n",
"syntax doesn't require parentheses around tuples used in expressions\n", "one-by-one in order. There are also two functions to generate string representations\n",
"where they would be redundant.\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", "output_type": "stream",
"text": [ "text": [
"def joy(stack, expression, dictionary, viewer=None):\n", "def joy(stack, expression, dictionary, viewer=None):\n",
" '''\n", "\t'''Evaluate a Joy expression on a stack.\n",
" Evaluate the Joy expression on the stack.\n",
" '''\n",
" while expression:\n",
"\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", "\n",
" term, expression = expression\n", "\tThe viewer is a function that is called with the stack and expression\n",
" if isinstance(term, Symbol):\n", "\ton every iteration, its return value is ignored.\n",
" term = dictionary[term]\n",
" stack, expression, dictionary = term(stack, expression, dictionary)\n",
" else:\n",
" stack = term, stack\n",
"\n", "\n",
" if viewer: viewer(stack, expression)\n", "\t:param stack stack: The stack.\n",
" return stack, expression, dictionary\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" "\n"
] ]
} }
@ -304,19 +317,22 @@
"name": "stdout", "name": "stdout",
"output_type": "stream", "output_type": "stream",
"text": [ "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", "\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", "\n",
" text_to_expression(text)\n", "A crude grammar::\n",
"\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", "\n",
" ParseError\n", "A Joy expression is a sequence of zero or more terms. A term is a\n",
"\n", "literal value (integer, float, string, or Joy expression) or a function\n",
"When supplied with a string this function returns a Python datastructure\n", "symbol. Function symbols are unquoted strings and cannot contain square\n",
"that represents the Joy datastructure described by the text expression.\n", "brackets. Terms must be separated by blanks, which can be omitted\n",
"Any unbalanced square brackets will raise a ParseError.\n" "around square brackets.\n"
] ]
} }
], ],
@ -343,27 +359,27 @@
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"def _parse(tokens):\n", "def _parse(tokens):\n",
" '''\n", "\t'''\n",
" Return a stack/list expression of the tokens.\n", "\tReturn a stack/list expression of the tokens.\n",
" '''\n", "\t'''\n",
" frame = []\n", "\tframe = []\n",
" stack = []\n", "\tstack = []\n",
" for tok in tokens:\n", "\tfor tok in tokens:\n",
" if tok == '[':\n", "\t\tif tok == '[':\n",
" stack.append(frame)\n", "\t\t\tstack.append(frame)\n",
" frame = []\n", "\t\t\tframe = []\n",
" stack[-1].append(frame)\n", "\t\t\tstack[-1].append(frame)\n",
" elif tok == ']':\n", "\t\telif tok == ']':\n",
" try:\n", "\t\t\ttry:\n",
" frame = stack.pop()\n", "\t\t\t\tframe = stack.pop()\n",
" except IndexError:\n", "\t\t\texcept IndexError:\n",
" raise ParseError('One or more extra closing brackets.')\n", "\t\t\t\traise ParseError('Extra closing bracket.')\n",
" frame[-1] = list_to_stack(frame[-1])\n", "\t\t\tframe[-1] = list_to_stack(frame[-1])\n",
" else:\n", "\t\telse:\n",
" frame.append(tok)\n", "\t\t\tframe.append(tok)\n",
" if stack:\n", "\tif stack:\n",
" raise ParseError('One or more unclosed brackets.')\n", "\t\traise ParseError('Unclosed bracket.')\n",
" return list_to_stack(frame)\n", "\treturn list_to_stack(frame)\n",
"\n" "\n"
] ]
} }
@ -498,7 +514,7 @@
"name": "stdout", "name": "stdout",
"output_type": "stream", "output_type": "stream",
"text": [ "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", "name": "stdout",
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"@inscribe\n",
"@combinator_effect(_COMB_NUMS(), a1, s1)\n",
"@FunctionWrapper\n",
"def dip(stack, expression, dictionary):\n", "def dip(stack, expression, dictionary):\n",
" (quote, (x, stack)) = stack\n", "\t'''\n",
" expression = x, expression\n", "\tThe dip combinator expects a quoted program on the stack and below it\n",
" return stack, pushback(quote, expression), dictionary\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" "\n"
] ]
} }
@ -552,28 +582,26 @@
"name": "stdout", "name": "stdout",
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"second == rest first\n", "ii == [dip] dupdip i\n",
"third == rest rest first\n", "of == swap at\n",
"product == 1 swap [*] step\n", "product == 1 swap [*] step\n",
"swons == swap cons\n",
"swoncat == swap concat\n",
"flatten == [] swap [concat] step\n", "flatten == [] swap [concat] step\n",
"unit == [] cons\n",
"quoted == [unit] dip\n", "quoted == [unit] dip\n",
"unquoted == [i] dip\n", "unquoted == [i] dip\n",
"enstacken == stack [clear] dip\n", "enstacken == stack [clear] dip\n",
"disenstacken == ? [uncons ?] loop pop\n",
"? == dup truthy\n", "? == dup truthy\n",
"disenstacken == ? [uncons ?] loop pop\n",
"dinfrirst == dip infra first\n", "dinfrirst == dip infra first\n",
"nullary == [stack] dinfrirst\n", "nullary == [stack] dinfrirst\n",
"unary == [stack [pop] dip] dinfrirst\n", "unary == nullary popd\n",
"binary == [stack [popop] dip] dinfrirst\n", "binary == nullary [popop] dip\n",
"ternary == [stack [popop pop] dip] dinfrirst\n", "ternary == unary [popop] dip\n",
"pam == [i] map\n", "pam == [i] map\n",
"run == [] swap infra\n", "run == [] swap infra\n",
"sqr == dup mul\n", "sqr == dup mul\n",
"size == 0 swap [pop ++] step\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", "average == [sum 1.0 *] [size] cleave /\n",
"gcd == 1 [tuck modulus dup 0 >] loop pop\n", "gcd == 1 [tuck modulus dup 0 >] loop pop\n",
"least_fraction == dup [gcd] infra [div] concat map\n", "least_fraction == dup [gcd] infra [div] concat map\n",
@ -584,8 +612,12 @@
"anamorphism == [pop []] swap [dip swons] genrec\n", "anamorphism == [pop []] swap [dip swons] genrec\n",
"range == [0 <=] [1 - dup] anamorphism\n", "range == [0 <=] [1 - dup] anamorphism\n",
"while == swap [nullary] cons dup dipd concat loop\n", "while == swap [nullary] cons dup dipd concat loop\n",
"dudipd == dup dipd\n", "dupdipd == dup dipd\n",
"primrec == [i] genrec\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" "\n"
] ]
} }

7
docs/1._Basic_Use_of_Joy_in_a_Notebook.ipynb
View File

@ -214,6 +214,13 @@
"source": [ "source": [
"V('96 27 gcd')" "V('96 27 gcd')"
] ]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
} }
], ],
"metadata": { "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="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html"> <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> <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>
</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><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> </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>
</div> </div>
@ -11941,7 +11942,7 @@ scan == [size 1 &lt;=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
</div> </div>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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>
<div class="cell border-box-sizing code_cell rendered"> <div class="cell border-box-sizing code_cell rendered">
<div class="input"> <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="inner_cell">
<div class="input_area"> <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> <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 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. ## 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: > 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 > 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 ## Designing the Recursive Function
Ignoring the exact requirements (finding `f` and `⨂`) can we implement `scan` as a hylomorphism in Joy? 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 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. 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 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/library.html">joy.library</a></li>
<li><a href="joy/parser.html">joy.parser</a></li> <li><a href="joy/parser.html">joy.parser</a></li>
<li><a href="joy/utils/generated_library.html">joy.utils.generated_library</a></li> <li><a href="joy/utils/generated_library.html">joy.utils.generated_library</a></li>
<li><a href="joy/utils/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/pretty_print.html">joy.utils.pretty_print</a></li>
<li><a href="joy/utils/stack.html">joy.utils.stack</a></li> <li><a href="joy/utils/stack.html">joy.utils.stack</a></li>
<li><a href="joy/utils/types.html">joy.utils.types</a></li> <li><a href="joy/utils/types.html">joy.utils.types</a></li>

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

@ -57,10 +57,7 @@
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span> <span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="k">try</span><span class="p">:</span> <span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">input</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">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="p">,</span> <span class="n">format_exc</span> <span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="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">.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> <span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">stack_to_string</span>
@ -68,12 +65,15 @@
<div class="viewcode-block" id="joy"><a class="viewcode-back" href="../../joy.html#joy.joy.joy">[docs]</a><span class="k">def</span> <span class="nf">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <div class="viewcode-block" id="joy"><a class="viewcode-back" href="../../joy.html#joy.joy.joy">[docs]</a><span class="k">def</span> <span class="nf">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Evaluate the Joy expression on the stack.</span> <span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a stack.</span>
<span class="sd"> </span>
<span class="sd"> The basic joy() function is quite straightforward. It iterates through a</span> <span class="sd"> This function iterates through a sequence of terms which are either</span>
<span class="sd"> sequence of terms which are either literals (strings, numbers, sequences)</span> <span class="sd"> literals (strings, numbers, sequences of terms) or function symbols.</span>
<span class="sd"> or functions. Literals are put onto the stack and functions are</span> <span class="sd"> Literals are put onto the stack and functions are looked up in the</span>
<span class="sd"> executed.</span> <span class="sd"> disctionary and executed.</span>
<span class="sd"> The viewer is a function that is called with the stack and expression</span>
<span class="sd"> on every iteration, its return value is ignored.</span>
<span class="sd"> :param stack stack: The stack.</span> <span class="sd"> :param stack stack: The stack.</span>
<span class="sd"> :param stack expression: The expression to evaluate.</span> <span class="sd"> :param stack expression: The expression to evaluate.</span>

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

@ -56,18 +56,86 @@
<span class="sd">returns a dictionary of Joy functions suitable for use with the joy()</span> <span class="sd">returns a dictionary of Joy functions suitable for use with the joy()</span>
<span class="sd">function.</span> <span class="sd">function.</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span><span class="p">,</span> <span class="nb">object</span><span class="p">,</span> <span class="nb">range</span><span class="p">,</span> <span class="nb">zip</span>
<span class="kn">from</span> <span class="nn">logging</span> <span class="k">import</span> <span class="n">getLogger</span>
<span class="n">_log</span> <span class="o">=</span> <span class="n">getLogger</span><span class="p">(</span><span class="vm">__name__</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Loading library.&#39;</span><span class="p">)</span>
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getdoc</span> <span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getdoc</span>
<span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span> <span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span>
<span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">count</span>
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span> <span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span>
<span class="kn">import</span> <span class="nn">operator</span><span class="o">,</span> <span class="nn">math</span> <span class="kn">import</span> <span class="nn">operator</span><span class="o">,</span> <span class="nn">math</span>
<span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">Symbol</span> <span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">Symbol</span>
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">list_to_stack</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">,</span> <span class="n">pick</span><span class="p">,</span> <span class="n">concat</span> <span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">list_to_stack</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">,</span> <span class="n">pick</span><span class="p">,</span> <span class="n">concat</span>
<span class="kn">from</span> <span class="nn">.utils.brutal_hackery</span> <span class="k">import</span> <span class="n">rename_code_object</span> <span class="kn">import</span> <span class="nn">sys</span>
<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="o">.</span><span class="n">major</span> <span class="o">&lt;</span> <span class="mi">3</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.utils.brutal_hackery</span> <span class="k">import</span> <span class="n">rename_code_object</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">rename_code_object</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">:</span> <span class="k">lambda</span> <span class="n">f</span><span class="p">:</span> <span class="n">f</span>
<span class="kn">from</span> <span class="nn">.utils</span> <span class="k">import</span> <span class="n">generated_library</span> <span class="k">as</span> <span class="n">genlib</span> <span class="kn">from</span> <span class="nn">.utils</span> <span class="k">import</span> <span class="n">generated_library</span> <span class="k">as</span> <span class="n">genlib</span>
<span class="kn">from</span> <span class="nn">.utils.types</span> <span class="k">import</span> <span class="p">(</span>
<span class="n">compose</span><span class="p">,</span>
<span class="n">ef</span><span class="p">,</span>
<span class="n">stack_effect</span><span class="p">,</span>
<span class="n">AnyJoyType</span><span class="p">,</span>
<span class="n">AnyStarJoyType</span><span class="p">,</span>
<span class="n">BooleanJoyType</span><span class="p">,</span>
<span class="n">NumberJoyType</span><span class="p">,</span>
<span class="n">NumberStarJoyType</span><span class="p">,</span>
<span class="n">StackJoyType</span><span class="p">,</span>
<span class="n">StackStarJoyType</span><span class="p">,</span>
<span class="n">FloatJoyType</span><span class="p">,</span>
<span class="n">IntJoyType</span><span class="p">,</span>
<span class="n">SymbolJoyType</span><span class="p">,</span>
<span class="n">CombinatorJoyType</span><span class="p">,</span>
<span class="n">TextJoyType</span><span class="p">,</span>
<span class="n">_functions</span><span class="p">,</span>
<span class="n">FUNCTIONS</span><span class="p">,</span>
<span class="n">infer</span><span class="p">,</span>
<span class="n">infer_expression</span><span class="p">,</span>
<span class="n">JoyTypeError</span><span class="p">,</span>
<span class="n">combinator_effect</span><span class="p">,</span>
<span class="n">poly_combinator_effect</span><span class="p">,</span>
<span class="n">doc_from_stack_effect</span><span class="p">,</span>
<span class="p">)</span>
<span class="n">_SYM_NUMS</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">c</span><span class="o">=</span><span class="n">count</span><span class="p">():</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">_COMB_NUMS</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">c</span><span class="o">=</span><span class="n">count</span><span class="p">():</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">_R</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">))</span>
<span class="n">A</span> <span class="o">=</span> <span class="n">a0</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a4</span><span class="p">,</span> <span class="n">a5</span><span class="p">,</span> <span class="n">a6</span><span class="p">,</span> <span class="n">a7</span><span class="p">,</span> <span class="n">a8</span><span class="p">,</span> <span class="n">a9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">AnyJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">B</span> <span class="o">=</span> <span class="n">b0</span><span class="p">,</span> <span class="n">b1</span><span class="p">,</span> <span class="n">b2</span><span class="p">,</span> <span class="n">b3</span><span class="p">,</span> <span class="n">b4</span><span class="p">,</span> <span class="n">b5</span><span class="p">,</span> <span class="n">b6</span><span class="p">,</span> <span class="n">b7</span><span class="p">,</span> <span class="n">b8</span><span class="p">,</span> <span class="n">b9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">BooleanJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">N</span> <span class="o">=</span> <span class="n">n0</span><span class="p">,</span> <span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">,</span> <span class="n">n3</span><span class="p">,</span> <span class="n">n4</span><span class="p">,</span> <span class="n">n5</span><span class="p">,</span> <span class="n">n6</span><span class="p">,</span> <span class="n">n7</span><span class="p">,</span> <span class="n">n8</span><span class="p">,</span> <span class="n">n9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">NumberJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">S</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">,</span> <span class="n">s3</span><span class="p">,</span> <span class="n">s4</span><span class="p">,</span> <span class="n">s5</span><span class="p">,</span> <span class="n">s6</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s8</span><span class="p">,</span> <span class="n">s9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">StackJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">F</span> <span class="o">=</span> <span class="n">f0</span><span class="p">,</span> <span class="n">f1</span><span class="p">,</span> <span class="n">f2</span><span class="p">,</span> <span class="n">f3</span><span class="p">,</span> <span class="n">f4</span><span class="p">,</span> <span class="n">f5</span><span class="p">,</span> <span class="n">f6</span><span class="p">,</span> <span class="n">f7</span><span class="p">,</span> <span class="n">f8</span><span class="p">,</span> <span class="n">f9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">FloatJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">I</span> <span class="o">=</span> <span class="n">i0</span><span class="p">,</span> <span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">,</span> <span class="n">i3</span><span class="p">,</span> <span class="n">i4</span><span class="p">,</span> <span class="n">i5</span><span class="p">,</span> <span class="n">i6</span><span class="p">,</span> <span class="n">i7</span><span class="p">,</span> <span class="n">i8</span><span class="p">,</span> <span class="n">i9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">IntJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">T</span> <span class="o">=</span> <span class="n">t0</span><span class="p">,</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">,</span> <span class="n">t3</span><span class="p">,</span> <span class="n">t4</span><span class="p">,</span> <span class="n">t5</span><span class="p">,</span> <span class="n">t6</span><span class="p">,</span> <span class="n">t7</span><span class="p">,</span> <span class="n">t8</span><span class="p">,</span> <span class="n">t9</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">TextJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">_R</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">))</span>
<span class="n">As</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">AnyStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">Ns</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">NumberStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">Ss</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">StackStarJoyType</span><span class="p">,</span> <span class="n">_R</span><span class="p">))</span>
<span class="n">sec0</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">t1</span><span class="p">)()</span>
<span class="n">sec1</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">i1</span><span class="p">)(</span><span class="n">s1</span><span class="p">)</span>
<span class="n">sec2</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">i1</span><span class="p">)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">sec_binary_cmp</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">)(</span><span class="n">b1</span><span class="p">)</span>
<span class="n">sec_binary_ints</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">)(</span><span class="n">i3</span><span class="p">)</span>
<span class="n">sec_binary_logic</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">b1</span><span class="p">,</span> <span class="n">b2</span><span class="p">)(</span><span class="n">b3</span><span class="p">)</span>
<span class="n">sec_binary_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">,</span> <span class="n">n2</span><span class="p">)(</span><span class="n">n3</span><span class="p">)</span>
<span class="n">sec_unary_logic</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">a1</span><span class="p">)(</span><span class="n">b1</span><span class="p">)</span>
<span class="n">sec_unary_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">)(</span><span class="n">n2</span><span class="p">)</span>
<span class="n">sec_Ns_math</span> <span class="o">=</span> <span class="n">stack_effect</span><span class="p">((</span><span class="n">Ns</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">s1</span><span class="p">),)(</span><span class="n">n0</span><span class="p">)</span>
<span class="n">_dictionary</span> <span class="o">=</span> <span class="p">{}</span> <span class="n">_dictionary</span> <span class="o">=</span> <span class="p">{}</span>
@ -87,6 +155,8 @@
<span class="p">(</span><span class="s1">&#39;and&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&amp;&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;and&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;&amp;&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;bool&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;truthy&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;bool&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;truthy&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;mul&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;*&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;mul&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;*&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;floordiv&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;/floor&#39;</span><span class="p">,</span> <span class="s1">&#39;//&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;floor&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;round&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;truediv&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;/&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;truediv&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;/&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;mod&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;%&#39;</span><span class="p">,</span> <span class="s1">&#39;rem&#39;</span><span class="p">,</span> <span class="s1">&#39;remainder&#39;</span><span class="p">,</span> <span class="s1">&#39;modulus&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;mod&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;%&#39;</span><span class="p">,</span> <span class="s1">&#39;rem&#39;</span><span class="p">,</span> <span class="s1">&#39;remainder&#39;</span><span class="p">,</span> <span class="s1">&#39;modulus&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;eq&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;=&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;eq&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;=&#39;</span><span class="p">]),</span>
@ -104,6 +174,7 @@
<span class="p">(</span><span class="s1">&#39;pred&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;--&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;pred&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;--&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;rolldown&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&lt;&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;rolldown&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&lt;&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;rollup&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&gt;&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;rollup&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;roll&gt;&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;eh&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;?&#39;</span><span class="p">]),</span>
<span class="p">(</span><span class="s1">&#39;id&#39;</span><span class="p">,</span> <span class="p">[</span><span class="sa">u</span><span class="s1">&#39;•&#39;</span><span class="p">]),</span> <span class="p">(</span><span class="s1">&#39;id&#39;</span><span class="p">,</span> <span class="p">[</span><span class="sa">u</span><span class="s1">&#39;•&#39;</span><span class="p">]),</span>
<span class="p">)</span> <span class="p">)</span>
@ -123,15 +194,66 @@
<span class="n">D</span><span class="p">[</span><span class="n">alias</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div> <span class="n">D</span><span class="p">[</span><span class="n">alias</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div>
<div class="viewcode-block" id="yin_functions"><a class="viewcode-back" href="../../library.html#joy.library.yin_functions">[docs]</a><span class="k">def</span> <span class="nf">yin_functions</span><span class="p">():</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return a dict of named stack effects.</span>
<span class="sd"> &quot;Yin&quot; functions are those that only rearrange items in stacks and</span>
<span class="sd"> can be defined completely by their stack effects. This means they</span>
<span class="sd"> can be auto-compiled.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># pylint: disable=unused-variable</span>
<span class="n">cons</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">)((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">))</span>
<span class="n">ccons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="n">dup</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">dupd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">dupdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">first</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">),)(</span><span class="n">a1</span><span class="p">,)</span>
<span class="n">over</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)</span>
<span class="n">pop</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)()</span>
<span class="n">popd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">popdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)</span>
<span class="n">popop</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)()</span>
<span class="n">popopd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a1</span><span class="p">)</span>
<span class="n">popopdd</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a4</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">rest</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),)(</span><span class="n">s0</span><span class="p">,)</span>
<span class="n">rolldown</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">rollup</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a3</span><span class="p">)(</span><span class="n">a3</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)</span>
<span class="n">rrest</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span>
<span class="n">second</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">first</span><span class="p">)</span>
<span class="n">stack</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">s0</span><span class="p">)</span>
<span class="n">swaack</span> <span class="o">=</span> <span class="p">(</span><span class="n">s1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),</span> <span class="p">(</span><span class="n">s0</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="n">swap</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">)(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">swons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">swap</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
<span class="n">third</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">second</span><span class="p">)</span>
<span class="n">tuck</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">)</span>
<span class="n">uncons</span> <span class="o">=</span> <span class="n">ef</span><span class="p">((</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">),)(</span><span class="n">a1</span><span class="p">,</span> <span class="n">s0</span><span class="p">)</span>
<span class="n">unswons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">uncons</span><span class="p">,</span> <span class="n">swap</span><span class="p">)</span>
<span class="n">stuncons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">uncons</span><span class="p">)</span>
<span class="n">stununcons</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">uncons</span><span class="p">,</span> <span class="n">uncons</span><span class="p">)</span>
<span class="n">unit</span> <span class="o">=</span> <span class="n">ef</span><span class="p">(</span><span class="n">a1</span><span class="p">)((</span><span class="n">a1</span><span class="p">,</span> <span class="p">()))</span>
<span class="n">first_two</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">uncons</span><span class="p">,</span> <span class="n">uncons</span><span class="p">,</span> <span class="n">pop</span><span class="p">)</span>
<span class="n">fourth</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rest</span><span class="p">,</span> <span class="n">third</span><span class="p">)</span>
<span class="n">_Tree_add_Ee</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rrest</span><span class="p">,</span> <span class="n">ccons</span><span class="p">)</span>
<span class="n">_Tree_get_E</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">popop</span><span class="p">,</span> <span class="n">second</span><span class="p">)</span>
<span class="n">_Tree_delete_clear_stuff</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">rollup</span><span class="p">,</span> <span class="n">popop</span><span class="p">,</span> <span class="n">rest</span><span class="p">)</span>
<span class="n">_Tree_delete_R0</span> <span class="o">=</span> <span class="n">compose</span><span class="p">(</span><span class="n">over</span><span class="p">,</span> <span class="n">first</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">dup</span><span class="p">)</span>
<span class="k">return</span> <span class="nb">locals</span><span class="p">()</span></div>
<span class="n">definitions</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span> <span class="n">definitions</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
<span class="s1">ii == [dip] dupdip i</span>
<span class="s1">of == swap at</span> <span class="s1">of == swap at</span>
<span class="s1">product == 1 swap [*] step</span> <span class="s1">product == 1 swap [*] step</span>
<span class="s1">flatten == [] swap [concat] step</span> <span class="s1">flatten == [] swap [concat] step</span>
<span class="s1">quoted == [unit] dip</span> <span class="s1">quoted == [unit] dip</span>
<span class="s1">unquoted == [i] dip</span> <span class="s1">unquoted == [i] dip</span>
<span class="s1">enstacken == stack [clear] dip</span> <span class="s1">enstacken == stack [clear] dip</span>
<span class="s1">disenstacken == ? [uncons ?] loop pop</span>
<span class="s1">? == dup truthy</span> <span class="s1">? == dup truthy</span>
<span class="s1">disenstacken == ? [uncons ?] loop pop</span>
<span class="s1">dinfrirst == dip infra first</span> <span class="s1">dinfrirst == dip infra first</span>
<span class="s1">nullary == [stack] dinfrirst</span> <span class="s1">nullary == [stack] dinfrirst</span>
<span class="s1">unary == nullary popd</span> <span class="s1">unary == nullary popd</span>
@ -160,7 +282,8 @@
<span class="s1">make_generator == [codireco] ccons</span> <span class="s1">make_generator == [codireco] ccons</span>
<span class="s1">ifte == [nullary not] dipd branch</span> <span class="s1">ifte == [nullary not] dipd branch</span>
<span class="s1">&#39;&#39;&#39;</span> <span class="s1">&#39;&#39;&#39;</span>
<span class="c1"># </span> <span class="c1">#</span>
<span class="c1">#</span>
<span class="c1"># ifte == [nullary] dipd swap branch</span> <span class="c1"># ifte == [nullary] dipd swap branch</span>
<span class="c1"># genrec == [[genrec] cons cons cons cons] nullary swons concat ifte</span> <span class="c1"># genrec == [[genrec] cons cons cons cons] nullary swons concat ifte</span>
@ -264,7 +387,7 @@
<span class="k">def</span> <span class="nf">__call__</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="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">__call__</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="n">dictionary</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">:</span> <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_compiled</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span> <span class="c1"># pylint: disable=E1102</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_body</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_body</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> <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>
@ -289,12 +412,20 @@
<span class="n">class_</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span></div> <span class="n">class_</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span></div>
<div class="viewcode-block" id="DefinitionWrapper.add_def"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper.add_def">[docs]</a> <span class="nd">@classmethod</span> <div class="viewcode-block" id="DefinitionWrapper.add_def"><a class="viewcode-back" href="../../library.html#joy.library.DefinitionWrapper.add_def">[docs]</a> <span class="nd">@classmethod</span>
<span class="k">def</span> <span class="nf">add_def</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">add_def</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">fail_fails</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Add the definition to the dictionary.</span> <span class="sd"> Add the definition to the dictionary.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="n">F</span> <span class="o">=</span> <span class="n">class_</span><span class="o">.</span><span class="n">parse_definition</span><span class="p">(</span><span class="n">definition</span><span class="p">)</span> <span class="n">F</span> <span class="o">=</span> <span class="n">class_</span><span class="o">.</span><span class="n">parse_definition</span><span class="p">(</span><span class="n">definition</span><span class="p">)</span>
<span class="n">dictionary</span><span class="p">[</span><span class="n">F</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div></div> <span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Adding definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">F</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">F</span><span class="o">.</span><span class="n">body</span><span class="p">))</span>
<span class="n">dictionary</span><span class="p">[</span><span class="n">F</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span></div>
<span class="nd">@classmethod</span>
<span class="k">def</span> <span class="nf">load_definitions</span><span class="p">(</span><span class="n">class_</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
<span class="n">lines</span> <span class="o">=</span> <span class="p">[</span><span class="n">line</span> <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">f</span> <span class="k">if</span> <span class="s1">&#39;==&#39;</span> <span class="ow">in</span> <span class="n">line</span><span class="p">]</span>
<span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span><span class="p">:</span>
<span class="n">class_</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">line</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_text_to_defs</span><span class="p">(</span><span class="n">text</span><span class="p">):</span> <span class="k">def</span> <span class="nf">_text_to_defs</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
@ -306,9 +437,23 @@
<span class="c1">#</span> <span class="c1">#</span>
<span class="c1"># Load the auto-generated primitives into the dictionary.</span> <div class="viewcode-block" id="inscribe_"><a class="viewcode-back" href="../../library.html#joy.library.inscribe_">[docs]</a><span class="nd">@inscribe</span>
<span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">primitive</span> <span class="ow">in</span> <span class="n">getmembers</span><span class="p">(</span><span class="n">genlib</span><span class="p">,</span> <span class="n">isfunction</span><span class="p">):</span> <span class="nd">@sec0</span>
<span class="n">inscribe</span><span class="p">(</span><span class="n">SimpleFunctionWrapper</span><span class="p">(</span><span class="n">primitive</span><span class="p">))</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">inscribe_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Create a new Joy function definition in the Joy dictionary. A</span>
<span class="sd"> definition is given as a string with a name followed by a double</span>
<span class="sd"> equal sign then one or more Joy functions, the body. for example:</span>
<span class="sd"> sqr == dup mul</span>
<span class="sd"> If you want the definition to persist over restarts, enter it into</span>
<span class="sd"> the definitions.txt resource.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">definition</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_def</span><span class="p">(</span><span class="n">definition</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">fail_fails</span><span class="o">=</span><span class="kc">True</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="parse"><a class="viewcode-back" href="../../library.html#joy.library.parse">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="parse"><a class="viewcode-back" href="../../library.html#joy.library.parse">[docs]</a><span class="nd">@inscribe</span>
@ -320,7 +465,18 @@
<span class="k">return</span> <span class="n">expression</span><span class="p">,</span> <span class="n">stack</span></div> <span class="k">return</span> <span class="n">expression</span><span class="p">,</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="infer_"><a class="viewcode-back" href="../../library.html#joy.library.infer_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">infer_</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Attempt to infer the stack effect of a Joy expression.&#39;&#39;&#39;</span>
<span class="n">E</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">effects</span> <span class="o">=</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">E</span><span class="p">)</span>
<span class="n">e</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">([(</span><span class="n">fi</span><span class="p">,</span> <span class="p">(</span><span class="n">fo</span><span class="p">,</span> <span class="p">()))</span> <span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">effects</span><span class="p">])</span>
<span class="k">return</span> <span class="n">e</span><span class="p">,</span> <span class="n">stack</span></div>
<div class="viewcode-block" id="getitem"><a class="viewcode-back" href="../../library.html#joy.library.getitem">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="getitem"><a class="viewcode-back" href="../../library.html#joy.library.getitem">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec2</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">getitem</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <span class="k">def</span> <span class="nf">getitem</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -342,6 +498,7 @@
<div class="viewcode-block" id="drop"><a class="viewcode-back" href="../../library.html#joy.library.drop">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="drop"><a class="viewcode-back" href="../../library.html#joy.library.drop">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec1</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">drop</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <span class="k">def</span> <span class="nf">drop</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -369,6 +526,7 @@
<div class="viewcode-block" id="take"><a class="viewcode-back" href="../../library.html#joy.library.take">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="take"><a class="viewcode-back" href="../../library.html#joy.library.take">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec1</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">take</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <span class="k">def</span> <span class="nf">take</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -443,6 +601,7 @@
<div class="viewcode-block" id="max_"><a class="viewcode-back" href="../../library.html#joy.library.max_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="max_"><a class="viewcode-back" href="../../library.html#joy.library.max_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">max_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">max_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a list find the maximum.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;Given a list find the maximum.&#39;&#39;&#39;</span>
@ -451,6 +610,7 @@
<div class="viewcode-block" id="min_"><a class="viewcode-back" href="../../library.html#joy.library.min_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="min_"><a class="viewcode-back" href="../../library.html#joy.library.min_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">min_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">min_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a list find the minimum.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;Given a list find the minimum.&#39;&#39;&#39;</span>
@ -459,6 +619,7 @@
<div class="viewcode-block" id="sum_"><a class="viewcode-back" href="../../library.html#joy.library.sum_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="sum_"><a class="viewcode-back" href="../../library.html#joy.library.sum_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_Ns_math</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">sum_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">sum_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Given a quoted sequence of numbers return the sum.</span> <span class="sd">&#39;&#39;&#39;Given a quoted sequence of numbers return the sum.</span>
@ -494,7 +655,6 @@
<span class="sd">&#39;&#39;&#39;Given a list remove duplicate items.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;Given a list remove duplicate items.&#39;&#39;&#39;</span>
<span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span> <span class="n">tos</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">S</span>
<span class="n">I</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))</span> <span class="n">I</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))</span>
<span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">I</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="n">I</span><span class="o">.</span><span class="n">index</span><span class="p">))</span>
<span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">I</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="n">I</span><span class="o">.</span><span class="n">index</span><span class="p">)),</span> <span class="n">stack</span></div> <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">I</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="n">I</span><span class="o">.</span><span class="n">index</span><span class="p">)),</span> <span class="n">stack</span></div>
@ -506,6 +666,7 @@
<span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))),</span> <span class="n">stack</span></div> <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">tos</span><span class="p">))),</span> <span class="n">stack</span></div>
<span class="n">_functions</span><span class="p">[</span><span class="s1">&#39;clear&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s1</span>
<div class="viewcode-block" id="clear"><a class="viewcode-back" href="../../library.html#joy.library.clear">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="clear"><a class="viewcode-back" href="../../library.html#joy.library.clear">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span> <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
@ -547,6 +708,7 @@
<div class="viewcode-block" id="concat_"><a class="viewcode-back" href="../../library.html#joy.library.concat_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="concat_"><a class="viewcode-back" href="../../library.html#joy.library.concat_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">concat_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">concat_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Concatinate the two lists on the top of the stack.</span> <span class="sd">&#39;&#39;&#39;Concatinate the two lists on the top of the stack.</span>
@ -597,6 +759,7 @@
<div class="viewcode-block" id="succ"><a class="viewcode-back" href="../../library.html#joy.library.succ">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="succ"><a class="viewcode-back" href="../../library.html#joy.library.succ">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_unary_math</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">succ</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">succ</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Increment TOS.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;Increment TOS.&#39;&#39;&#39;</span>
@ -605,6 +768,7 @@
<div class="viewcode-block" id="pred"><a class="viewcode-back" href="../../library.html#joy.library.pred">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="pred"><a class="viewcode-back" href="../../library.html#joy.library.pred">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@sec_unary_math</span>
<span class="nd">@SimpleFunctionWrapper</span> <span class="nd">@SimpleFunctionWrapper</span>
<span class="k">def</span> <span class="nf">pred</span><span class="p">(</span><span class="n">S</span><span class="p">):</span> <span class="k">def</span> <span class="nf">pred</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Decrement TOS.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;Decrement TOS.&#39;&#39;&#39;</span>
@ -779,13 +943,14 @@
<span class="n">S_i</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;i&#39;</span><span class="p">)</span> <span class="n">S_i</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;i&#39;</span><span class="p">)</span>
<span class="n">S_ifte</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;ifte&#39;</span><span class="p">)</span> <span class="n">S_ifte</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;ifte&#39;</span><span class="p">)</span>
<span class="n">S_infra</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;infra&#39;</span><span class="p">)</span> <span class="n">S_infra</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;infra&#39;</span><span class="p">)</span>
<span class="n">S_pop</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;pop&#39;</span><span class="p">)</span>
<span class="n">S_step</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;step&#39;</span><span class="p">)</span> <span class="n">S_step</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;step&#39;</span><span class="p">)</span>
<span class="n">S_times</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;times&#39;</span><span class="p">)</span> <span class="n">S_times</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;times&#39;</span><span class="p">)</span>
<span class="n">S_swaack</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;swaack&#39;</span><span class="p">)</span> <span class="n">S_swaack</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;swaack&#39;</span><span class="p">)</span>
<span class="n">S_truthy</span> <span class="o">=</span> <span class="n">Symbol</span><span class="p">(</span><span class="s1">&#39;truthy&#39;</span><span class="p">)</span>
<div class="viewcode-block" id="i"><a class="viewcode-back" href="../../library.html#joy.library.i">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="i"><a class="viewcode-back" href="../../library.html#joy.library.i">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">i</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">i</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -803,6 +968,7 @@
<div class="viewcode-block" id="x"><a class="viewcode-back" href="../../library.html#joy.library.x">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="x"><a class="viewcode-back" href="../../library.html#joy.library.x">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">x</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -820,6 +986,7 @@
<div class="viewcode-block" id="b"><a class="viewcode-back" href="../../library.html#joy.library.b">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="b"><a class="viewcode-back" href="../../library.html#joy.library.b">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">b</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">b</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -836,6 +1003,7 @@
<div class="viewcode-block" id="dupdip"><a class="viewcode-back" href="../../library.html#joy.library.dupdip">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="dupdip"><a class="viewcode-back" href="../../library.html#joy.library.dupdip">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">dupdip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">dupdip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -855,11 +1023,12 @@
<div class="viewcode-block" id="infra"><a class="viewcode-back" href="../../library.html#joy.library.infra">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="infra"><a class="viewcode-back" href="../../library.html#joy.library.infra">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">infra</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">infra</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Accept a quoted program and a list on the stack and run the program</span> <span class="sd"> Accept a quoted program and a list on the stack and run the program</span>
<span class="sd"> with the list as its stack.</span> <span class="sd"> with the list as its stack. Does not affect the rest of the stack.</span>
<span class="sd"> ::</span> <span class="sd"> ::</span>
<span class="sd"> ... [a b c] [Q] . infra</span> <span class="sd"> ... [a b c] [Q] . infra</span>
@ -872,6 +1041,7 @@
<div class="viewcode-block" id="genrec"><a class="viewcode-back" href="../../library.html#joy.library.genrec">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="genrec"><a class="viewcode-back" href="../../library.html#joy.library.genrec">[docs]</a><span class="nd">@inscribe</span>
<span class="c1">#@combinator_effect(_COMB_NUMS(), s7, s6, s5, s4)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">genrec</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">genrec</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -933,11 +1103,12 @@
<div class="viewcode-block" id="map_"><a class="viewcode-back" href="../../library.html#joy.library.map_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="map_"><a class="viewcode-back" href="../../library.html#joy.library.map_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">map_</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">map_</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Run the quoted program on TOS on the items in the list under it, push a</span> <span class="sd"> Run the quoted program on TOS on the items in the list under it, push a</span>
<span class="sd"> new list with the results (in place of the program and original list.</span> <span class="sd"> new list with the results in place of the program and original list.</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="c1"># (quote, (aggregate, stack)) = S</span> <span class="c1"># (quote, (aggregate, stack)) = S</span>
<span class="c1"># results = list_to_stack([</span> <span class="c1"># results = list_to_stack([</span>
@ -970,7 +1141,20 @@
<span class="c1"># return (q, (p, stack)), expression, dictionary</span> <span class="c1"># return (q, (p, stack)), expression, dictionary</span>
<span class="k">def</span> <span class="nf">branch_true</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="c1"># pylint: disable=unused-variable</span>
<span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">branch_false</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="c1"># pylint: disable=unused-variable</span>
<span class="p">(</span><span class="n">then</span><span class="p">,</span> <span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">else_</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span>
<div class="viewcode-block" id="branch"><a class="viewcode-back" href="../../library.html#joy.library.branch">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="branch"><a class="viewcode-back" href="../../library.html#joy.library.branch">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@poly_combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="p">[</span><span class="n">branch_true</span><span class="p">,</span> <span class="n">branch_false</span><span class="p">],</span> <span class="n">b1</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">branch</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">branch</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -995,6 +1179,9 @@
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">then</span> <span class="k">if</span> <span class="n">flag</span> <span class="k">else</span> <span class="n">else_</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div> <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">then</span> <span class="k">if</span> <span class="n">flag</span> <span class="k">else</span> <span class="n">else_</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span></div>
<span class="c1">#FUNCTIONS[&#39;branch&#39;] = CombinatorJoyType(&#39;branch&#39;, [branch_true, branch_false], 100)</span>
<span class="c1">##@inscribe</span> <span class="c1">##@inscribe</span>
<span class="c1">##@FunctionWrapper</span> <span class="c1">##@FunctionWrapper</span>
<span class="c1">##def ifte(stack, expression, dictionary):</span> <span class="c1">##def ifte(stack, expression, dictionary):</span>
@ -1064,6 +1251,7 @@
<div class="viewcode-block" id="dip"><a class="viewcode-back" href="../../library.html#joy.library.dip">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="dip"><a class="viewcode-back" href="../../library.html#joy.library.dip">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1083,6 +1271,7 @@
<div class="viewcode-block" id="dipd"><a class="viewcode-back" href="../../library.html#joy.library.dipd">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="dipd"><a class="viewcode-back" href="../../library.html#joy.library.dipd">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">dipd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">dipd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1100,6 +1289,7 @@
<div class="viewcode-block" id="dipdd"><a class="viewcode-back" href="../../library.html#joy.library.dipdd">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="dipdd"><a class="viewcode-back" href="../../library.html#joy.library.dipdd">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">dipdd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">dipdd</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1117,6 +1307,7 @@
<div class="viewcode-block" id="app1"><a class="viewcode-back" href="../../library.html#joy.library.app1">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="app1"><a class="viewcode-back" href="../../library.html#joy.library.app1">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">app1</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">app1</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1136,6 +1327,7 @@
<div class="viewcode-block" id="app2"><a class="viewcode-back" href="../../library.html#joy.library.app2">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="app2"><a class="viewcode-back" href="../../library.html#joy.library.app2">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">app2</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">app2</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Like app1 with two items.</span> <span class="sd">&#39;&#39;&#39;Like app1 with two items.</span>
@ -1156,6 +1348,7 @@
<div class="viewcode-block" id="app3"><a class="viewcode-back" href="../../library.html#joy.library.app3">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="app3"><a class="viewcode-back" href="../../library.html#joy.library.app3">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a3</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">a1</span><span class="p">,</span> <span class="n">s1</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">app3</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">app3</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;Like app1 with three items.</span> <span class="sd">&#39;&#39;&#39;Like app1 with three items.</span>
@ -1178,6 +1371,7 @@
<div class="viewcode-block" id="step"><a class="viewcode-back" href="../../library.html#joy.library.step">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="step"><a class="viewcode-back" href="../../library.html#joy.library.step">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">step</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">step</span><span class="p">(</span><span class="n">S</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1213,6 +1407,7 @@
<div class="viewcode-block" id="times"><a class="viewcode-back" href="../../library.html#joy.library.times">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="times"><a class="viewcode-back" href="../../library.html#joy.library.times">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">i1</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">times</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">times</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1261,7 +1456,21 @@
<span class="c1"># return stack, expression, dictionary</span> <span class="c1"># return stack, expression, dictionary</span>
<span class="k">def</span> <span class="nf">loop_true</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span> <span class="c1"># pylint: disable=unused-variable</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_pop</span><span class="p">,</span> <span class="n">expression</span><span class="p">)),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">loop_two_true</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span> <span class="c1"># pylint: disable=unused-variable</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_pop</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">S_pop</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))),</span> <span class="n">dictionary</span>
<span class="k">def</span> <span class="nf">loop_false</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">flag</span><span class="p">,</span> <span class="n">stack</span><span class="p">)</span> <span class="o">=</span> <span class="n">stack</span> <span class="c1"># pylint: disable=unused-variable</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span>
<div class="viewcode-block" id="loop"><a class="viewcode-back" href="../../library.html#joy.library.loop">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="loop"><a class="viewcode-back" href="../../library.html#joy.library.loop">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@poly_combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="p">[</span><span class="n">loop_two_true</span><span class="p">,</span> <span class="n">loop_true</span><span class="p">,</span> <span class="n">loop_false</span><span class="p">],</span> <span class="n">b1</span><span class="p">,</span> <span class="n">s6</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">loop</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">loop</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1284,6 +1493,7 @@
<div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span> <div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@combinator_effect</span><span class="p">(</span><span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">a1</span><span class="p">,</span> <span class="n">a2</span><span class="p">,</span> <span class="n">s6</span><span class="p">,</span> <span class="n">s7</span><span class="p">,</span> <span class="n">s8</span><span class="p">)</span>
<span class="nd">@FunctionWrapper</span> <span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span> <span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
@ -1313,41 +1523,141 @@
<span class="k">for</span> <span class="n">F</span> <span class="ow">in</span> <span class="p">(</span> <span class="k">for</span> <span class="n">F</span> <span class="ow">in</span> <span class="p">(</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">and_</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">div</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">eq</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">floordiv</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">gt</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lshift</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lt</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mod</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ne</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">or_</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">pow</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">rshift</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">truediv</span><span class="p">),</span>
<span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">xor</span><span class="p">),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">abs</span><span class="p">),</span> <span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">floor</span><span class="p">),</span> <span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">eq</span><span class="p">)),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">neg</span><span class="p">),</span> <span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">)),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">),</span> <span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">gt</span><span class="p">)),</span>
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">),</span> <span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">)),</span>
<span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lt</span><span class="p">)),</span>
<span class="n">sec_binary_cmp</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">ne</span><span class="p">)),</span>
<span class="n">sec_binary_ints</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">xor</span><span class="p">)),</span>
<span class="n">sec_binary_ints</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">lshift</span><span class="p">)),</span>
<span class="n">sec_binary_ints</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">rshift</span><span class="p">)),</span>
<span class="n">sec_binary_logic</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">and_</span><span class="p">)),</span>
<span class="n">sec_binary_logic</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">or_</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">floordiv</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mod</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">pow</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">)),</span>
<span class="n">sec_binary_math</span><span class="p">(</span><span class="n">BinaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">truediv</span><span class="p">)),</span>
<span class="n">sec_unary_logic</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">bool</span><span class="p">)),</span>
<span class="n">sec_unary_logic</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">)),</span>
<span class="n">sec_unary_math</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="nb">abs</span><span class="p">)),</span>
<span class="n">sec_unary_math</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">neg</span><span class="p">)),</span>
<span class="n">sec_unary_math</span><span class="p">(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">)),</span>
<span class="n">stack_effect</span><span class="p">(</span><span class="n">n1</span><span class="p">)(</span><span class="n">i1</span><span class="p">)(</span><span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">floor</span><span class="p">)),</span>
<span class="p">):</span> <span class="p">):</span>
<span class="n">inscribe</span><span class="p">(</span><span class="n">F</span><span class="p">)</span> <span class="n">inscribe</span><span class="p">(</span><span class="n">F</span><span class="p">)</span>
<span class="k">del</span> <span class="n">F</span> <span class="c1"># Otherwise Sphinx autodoc will pick it up.</span> <span class="k">del</span> <span class="n">F</span> <span class="c1"># Otherwise Sphinx autodoc will pick it up.</span>
<span class="n">YIN_STACK_EFFECTS</span> <span class="o">=</span> <span class="n">yin_functions</span><span class="p">()</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">YIN_STACK_EFFECTS</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="c1"># Load the auto-generated primitives into the dictionary.</span>
<span class="n">_functions</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">YIN_STACK_EFFECTS</span><span class="p">)</span>
<span class="c1"># exec &#39;&#39;&#39;</span>
<span class="c1"># eh = compose(dup, bool)</span>
<span class="c1"># sqr = compose(dup, mul)</span>
<span class="c1"># of = compose(swap, at)</span>
<span class="c1"># &#39;&#39;&#39; in dict(compose=compose), _functions</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">_functions</span><span class="p">):</span>
<span class="n">sec</span> <span class="o">=</span> <span class="n">_functions</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">F</span> <span class="o">=</span> <span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">SymbolJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="p">[</span><span class="n">sec</span><span class="p">],</span> <span class="n">_SYM_NUMS</span><span class="p">())</span>
<span class="k">if</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">YIN_STACK_EFFECTS</span><span class="p">:</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Setting stack effect for Yin function </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">F</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">sec</span><span class="p">))</span>
<span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">primitive</span> <span class="ow">in</span> <span class="n">getmembers</span><span class="p">(</span><span class="n">genlib</span><span class="p">,</span> <span class="n">isfunction</span><span class="p">):</span>
<span class="n">inscribe</span><span class="p">(</span><span class="n">SimpleFunctionWrapper</span><span class="p">(</span><span class="n">primitive</span><span class="p">))</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">_dictionary</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span> <span class="n">add_aliases</span><span class="p">(</span><span class="n">_dictionary</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">_functions</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="n">add_aliases</span><span class="p">(</span><span class="n">FUNCTIONS</span><span class="p">,</span> <span class="n">ALIASES</span><span class="p">)</span>
<span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="n">definitions</span><span class="p">,</span> <span class="n">_dictionary</span><span class="p">)</span> <span class="n">DefinitionWrapper</span><span class="o">.</span><span class="n">add_definitions</span><span class="p">(</span><span class="n">definitions</span><span class="p">,</span> <span class="n">_dictionary</span><span class="p">)</span>
<span class="n">EXPECTATIONS</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span>
<span class="n">ifte</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="p">(</span><span class="n">s6</span><span class="p">,</span> <span class="p">(</span><span class="n">s5</span><span class="p">,</span> <span class="n">s4</span><span class="p">))),</span>
<span class="n">nullary</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">),</span>
<span class="n">run</span><span class="o">=</span><span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="n">s6</span><span class="p">),</span>
<span class="p">)</span>
<span class="n">EXPECTATIONS</span><span class="p">[</span><span class="s1">&#39;while&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">s7</span><span class="p">,</span> <span class="p">(</span><span class="n">s6</span><span class="p">,</span> <span class="n">s5</span><span class="p">))</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="s1">&#39;&#39;&#39;</span>
<span class="s1"> dinfrirst</span>
<span class="s1"> nullary</span>
<span class="s1"> ifte</span>
<span class="s1"> run</span>
<span class="s1"> dupdipd codireco</span>
<span class="s1"> while</span>
<span class="s1"> &#39;&#39;&#39;</span><span class="o">.</span><span class="n">split</span><span class="p">():</span>
<span class="n">C</span> <span class="o">=</span> <span class="n">_dictionary</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">expect</span> <span class="o">=</span> <span class="n">EXPECTATIONS</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
<span class="k">if</span> <span class="n">expect</span><span class="p">:</span>
<span class="n">sec</span> <span class="o">=</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">expect</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;Setting stack EXPECT for combinator </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">C</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">sec</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span><span class="s1">&#39;combinator </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span> <span class="n">C</span><span class="o">.</span><span class="n">name</span><span class="p">)</span>
<span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">CombinatorJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="p">[</span><span class="n">C</span><span class="p">],</span> <span class="n">_COMB_NUMS</span><span class="p">(),</span> <span class="n">expect</span><span class="p">)</span>
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1"> of quoted enstacken ?</span>
<span class="s1"> unary binary ternary</span>
<span class="s1"> sqr unquoted</span>
<span class="s1"> &#39;&#39;&#39;</span><span class="o">.</span><span class="n">split</span><span class="p">()):</span>
<span class="n">of_</span> <span class="o">=</span> <span class="n">_dictionary</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="n">secs</span> <span class="o">=</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">of_</span><span class="o">.</span><span class="n">body</span><span class="p">)</span>
<span class="k">assert</span> <span class="nb">len</span><span class="p">(</span><span class="n">secs</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">,</span> <span class="nb">repr</span><span class="p">(</span><span class="n">secs</span><span class="p">)</span>
<span class="n">_log</span><span class="o">.</span><span class="n">info</span><span class="p">(</span>
<span class="s1">&#39;Setting stack effect for definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">&#39;</span><span class="p">,</span>
<span class="n">name</span><span class="p">,</span>
<span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="o">*</span><span class="n">secs</span><span class="p">[</span><span class="mi">0</span><span class="p">]),</span>
<span class="p">)</span>
<span class="n">FUNCTIONS</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">SymbolJoyType</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">infer_expression</span><span class="p">(</span><span class="n">of_</span><span class="o">.</span><span class="n">body</span><span class="p">),</span> <span class="n">_SYM_NUMS</span><span class="p">())</span>
<span class="c1">#sec_Ns_math(_dictionary[&#39;product&#39;])</span>
<span class="c1">## product == 1 swap [*] step</span>
<span class="c1">## flatten == [] swap [concat] step</span>
<span class="c1">## disenstacken == ? [uncons ?] loop pop</span>
<span class="c1">## pam == [i] map</span>
<span class="c1">## size == 0 swap [pop ++] step</span>
<span class="c1">## fork == [i] app2</span>
<span class="c1">## cleave == fork [popd] dip</span>
<span class="c1">## average == [sum 1.0 *] [size] cleave /</span>
<span class="c1">## gcd == 1 [tuck modulus dup 0 &gt;] loop pop</span>
<span class="c1">## least_fraction == dup [gcd] infra [div] concat map</span>
<span class="c1">## *fraction == [uncons] dip uncons [swap] dip concat [*] infra [*] dip cons</span>
<span class="c1">## *fraction0 == concat [[swap] dip * [*] dip] infra</span>
<span class="c1">## down_to_zero == [0 &gt;] [dup --] while</span>
<span class="c1">## range_to_zero == unit [down_to_zero] infra</span>
<span class="c1">## anamorphism == [pop []] swap [dip swons] genrec</span>
<span class="c1">## range == [0 &lt;=] [1 - dup] anamorphism</span>
<span class="c1">## while == swap [nullary] cons dup dipd concat loop</span>
<span class="c1">## dupdipd == dup dipd</span>
<span class="c1">## primrec == [i] genrec</span>
<span class="c1">## step_zero == 0 roll&gt; step</span>
<span class="c1">## codireco == cons dip rest cons</span>
<span class="c1">## make_generator == [codireco] ccons</span>
<span class="c1">## ifte == [nullary not] dipd branch</span>
</pre></div> </pre></div>
</div> </div>

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

@ -60,17 +60,29 @@
<span class="sd">A crude grammar::</span> <span class="sd">A crude grammar::</span>
<span class="sd"> joy = term*</span> <span class="sd"> joy = term*</span>
<span class="sd"> term = int | float | string | &#39;[&#39; joy &#39;]&#39; | function</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</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="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">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="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> <div class="viewcode-block" id="Symbol"><a class="viewcode-back" href="../../parser.html#joy.parser.Symbol">[docs]</a><span class="k">class</span> <span class="nc">Symbol</span><span class="p">(</span><span class="nb">str</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span>
<span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div> <span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div>
@ -135,13 +147,13 @@
<span class="n">_scanner</span> <span class="o">=</span> <span class="n">Scanner</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="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="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="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="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="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="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="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="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="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="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="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="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="n">BLANKS</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
<span class="p">])</span> <span class="p">])</span>
</pre></div> </pre></div>

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

@ -73,6 +73,7 @@
<span class="c1"># (Kinda clunky and hacky. This should be swapped out in favor of much</span> <span class="c1"># (Kinda clunky and hacky. This should be swapped out in favor of much</span>
<span class="c1"># smarter stuff.)</span> <span class="c1"># smarter stuff.)</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span> <span class="kn">from</span> <span class="nn">__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">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> <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>

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

@ -105,6 +105,7 @@
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span>
<div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span> <div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span>
<span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span> <span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span>
@ -162,7 +163,6 @@
<span class="k">def</span> <span class="nf">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">):</span> <span class="k">def</span> <span class="nf">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">):</span>
<span class="k">if</span> <span class="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="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">if</span> <span class="ow">not</span> <span class="n">stack</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;&#39;</span> <span class="c1"># shortcut</span>
<span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span> <span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
@ -170,7 +170,6 @@
<span class="n">_s</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span> <span class="n">_s</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span>
<span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span> <span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">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="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="p">)</span>
@ -208,21 +207,21 @@
<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> <div class="viewcode-block" id="pick"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.pick">[docs]</a><span class="k">def</span> <span class="nf">pick</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span> <span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> Return the nth item on the stack.</span> <span class="sd"> Return the nth item on the stack.</span>
<span class="sd"> :param stack s: A stack.</span> <span class="sd"> :param stack stack: A stack.</span>
<span class="sd"> :param int n: An index into the stack.</span> <span class="sd"> :param int n: An index into the stack.</span>
<span class="sd"> :raises ValueError: if ``n`` is less than zero.</span> <span class="sd"> :raises ValueError: if ``n`` is less than zero.</span>
<span class="sd"> :raises IndexError: if ``n`` is equal to or greater than the length of ``s``.</span> <span class="sd"> :raises IndexError: if ``n`` is equal to or greater than the length of ``stack``.</span>
<span class="sd"> :rtype: whatever</span> <span class="sd"> :rtype: whatever</span>
<span class="sd"> &#39;&#39;&#39;</span> <span class="sd"> &#39;&#39;&#39;</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span> <span class="k">raise</span> <span class="ne">ValueError</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span> <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span> <span class="k">try</span><span class="p">:</span>
<span class="n">item</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">s</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">IndexError</span> <span class="k">raise</span> <span class="ne">IndexError</span>
<span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span> <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>

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

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

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"> <dl class="function">
<dt id="joy.joy.joy"> <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> <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> <dd><p>Evaluate a Joy expression on a stack.</p>
<p>The basic joy() function is quite straightforward. It iterates through a <p>This function iterates through a sequence of terms which are either
sequence of terms which are either literals (strings, numbers, sequences) literals (strings, numbers, sequences of terms) or function symbols.
or functions. Literals are put onto the stack and functions are Literals are put onto the stack and functions are looked up in the
executed.</p> 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"> <table class="docutils field-list" frame="void" rules="none">
<col class="field-name" /> <col class="field-name" />
<col class="field-body" /> <col class="field-body" />

94
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> <dd><p>Provide implementation of defined functions, and some helper methods.</p>
<dl class="classmethod"> <dl class="classmethod">
<dt id="joy.library.DefinitionWrapper.add_def"> <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><p>Add the definition to the dictionary.</p>
</dd></dl> </dd></dl>
@ -287,7 +287,8 @@ on the rest of the stack.</p>
<dl class="function"> <dl class="function">
<dt id="joy.library.drop"> <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> <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> </pre></div>
</div> </div>
<p>Expects an integer and a quote on the stack and returns the quote with <p>Expects an integer and a quote on the stack and returns the quote with
@ -297,6 +298,11 @@ n items removed off the top.</p>
<span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
</pre></div> </pre></div>
</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> </dd></dl>
<dl class="function"> <dl class="function">
@ -369,7 +375,8 @@ the original definition in the else-part:</p>
<dl class="function"> <dl class="function">
<dt id="joy.library.getitem"> <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> <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> </pre></div>
</div> </div>
<p>Expects an integer and a quote on the stack and returns the item at the <p>Expects an integer and a quote on the stack and returns the item at the
@ -379,6 +386,11 @@ nth position in the quote counting from 0.</p>
<span class="n">a</span> <span class="n">a</span>
</pre></div> </pre></div>
</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> </dd></dl>
<dl class="function"> <dl class="function">
@ -405,11 +417,17 @@ onto the pending expression for evaluation.</p>
<dd><p>The identity function.</p> <dd><p>The identity function.</p>
</dd></dl> </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"> <dl class="function">
<dt id="joy.library.infra"> <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> <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 <dd><p>Accept a quoted program and a list on the stack and run the program
with the list as its stack.</p> with the list as its stack. Does not affect the rest of the stack.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
<span class="o">-----------------------------</span> <span class="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>
@ -429,6 +447,24 @@ with the list as its stack.</p>
<dd><p>A decorator to inscribe functions into the default dictionary.</p> <dd><p>A decorator to inscribe functions into the default dictionary.</p>
</dd></dl> </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"> <dl class="function">
<dt id="joy.library.loop"> <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> <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>
@ -448,19 +484,27 @@ with the list as its stack.</p>
<dt id="joy.library.map_"> <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> <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 <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> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="joy.library.max_"> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="joy.library.min_"> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
@ -483,7 +527,11 @@ new list with the results (in place of the program and original list.</p>
<dl class="function"> <dl class="function">
<dt id="joy.library.pred"> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
@ -584,20 +632,30 @@ on top of the stack.</p>
<dl class="function"> <dl class="function">
<dt id="joy.library.succ"> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="joy.library.sum_"> <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> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="joy.library.take"> <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> <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 just the top n items in reverse order (because that’s easier and you can
use reverse if needed.)</p> 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>
@ -605,6 +663,11 @@ use reverse if needed.)</p>
<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> </pre></div>
</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> </dd></dl>
<dl class="function"> <dl class="function">
@ -671,6 +734,15 @@ the stack discarding the rest of the stack.</p>
</div> </div>
</dd></dl> </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"> <dl class="function">
<dt id="joy.library.zip_"> <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> <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> </pre></div>
</div> </div>
<p>Says, “Three or more 1’s and not ending in 01 nor composed of all 1’s.”</p> <p>Says, “Three or more 1’s and not ending in 01 nor composed of all 1’s.”</p>
<div class="figure"> <div class="figure" id="id2">
<img alt="State Machine Diagram" src="../_images/omg.svg" /></div> <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 <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 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 <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> by the fact that they are not Symbol objects.</p>
<p>A crude grammar:</p> <p>A crude grammar:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span>
<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">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> </pre></div>
</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"> <dl class="exception">
<dt id="joy.parser.ParseError"> <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> <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; <td>&#160;&#160;&#160;
<a href="library.html#module-joy.utils.generated_library"><code class="xref">joy.utils.generated_library</code></a></td><td> <a href="library.html#module-joy.utils.generated_library"><code class="xref">joy.utils.generated_library</code></a></td><td>
<em></em></td></tr> <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"> <tr class="cg-1">
<td></td> <td></td>
<td>&#160;&#160;&#160; <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

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

@ -168,21 +168,21 @@ won’t work because <code class="docutils literal notranslate"><span class="pre
<dl class="function"> <dl class="function">
<dt id="joy.utils.stack.pick"> <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> <dd><p>Return the nth item on the stack.</p>
<table class="docutils field-list" frame="void" rules="none"> <table class="docutils field-list" frame="void" rules="none">
<col class="field-name" /> <col class="field-name" />
<col class="field-body" /> <col class="field-body" />
<tbody valign="top"> <tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <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> <li><strong>n</strong> (<em>int</em>) – An index into the stack.</li>
</ul> </ul>
</td> </td>
</tr> </tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><ul class="first simple"> <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>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> </ul>
</td> </td>
</tr> </tr>

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

@ -117,6 +117,18 @@
</dd></dl> </dd></dl>
<dl class="class">
<dt id="joy.utils.types.CombinatorJoyType">
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.CombinatorJoyType" title="Permalink to this definition"></a></dt>
<dd><p>Represent combinators.</p>
<p>These type variables carry Joy functions that implement the
behaviour of Joy combinators and they can appear in expressions.
For simple combinators the implementation functions can be the
combinators themselves.</p>
<p>These types can also specify a stack effect (input side only) to
guard against being used on invalid types.</p>
</dd></dl>
<dl class="class"> <dl class="class">
<dt id="joy.utils.types.FloatJoyType"> <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> <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> </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"> <dl class="class">
<dt id="joy.utils.types.IntJoyType"> <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> <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> <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> <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"> <dl class="class">
<dt id="joy.utils.types.NumberJoyType"> <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> <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> </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"> <dl class="function">
<dt id="joy.utils.types.compilable"> <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> <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><p>Return the stack effect of the composition of some of stack effects.</p>
</dd></dl> </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"> <dl class="function">
<dt id="joy.utils.types.delabel"> <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> <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"> <dl class="function">
<dt id="joy.utils.types.doc_from_stack_effect"> <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><p>Return a crude string representation of a stack effect.</p>
</dd></dl> </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"> <dl class="function">
<dt id="joy.utils.types.reify"> <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> <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> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="joy.utils.types.unify"> <dt id="joy.utils.types.type_check">
<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> <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><p>Return a substitution dict representing a unifier for u and v.</p>
</dd></dl> </dd></dl>
@ -272,114 +363,6 @@ is used to generate one.</p>
(i2 i1 -- i3) (i2 i1 -- i3)
</pre></div> </pre></div>
</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>
</div> </div>