Rebuilt some docs. Minor edits.
This commit is contained in:
Simon Forman
parent
1863cba7f7
commit
14f706cd96
|
|
@ -67,17 +67,19 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"§ Stack\n",
|
||||
"When talking about Joy we use the terms \"stack\", \"quote\", \"sequence\",\n",
|
||||
"\"list\", and others to mean the same thing: a simple linear datatype that\n",
|
||||
"permits certain operations such as iterating and pushing and popping\n",
|
||||
"values from (at least) one end.\n",
|
||||
"\n",
|
||||
"There is no \"Stack\" Python class, instead we use the `cons list`_, a \n",
|
||||
"venerable two-tuple recursive sequence datastructure, where the\n",
|
||||
"empty tuple ``()`` is the empty stack and ``(head, rest)`` gives the recursive\n",
|
||||
"form of a stack with one or more items on it::\n",
|
||||
"\n",
|
||||
"When talking about Joy we use the terms \"stack\", \"list\", \"sequence\" and\n",
|
||||
"\"aggregate\" to mean the same thing: a simple datatype that permits\n",
|
||||
"certain operations such as iterating and pushing and popping values from\n",
|
||||
"(at least) one end.\n",
|
||||
" stack := () | (item, stack)\n",
|
||||
"\n",
|
||||
"We use the venerable two-tuple recursive form of sequences where the\n",
|
||||
"empty tuple () is the empty stack and (head, rest) gives the recursive\n",
|
||||
"form of a stack with one or more items on it.\n",
|
||||
"Putting some numbers onto a stack::\n",
|
||||
"\n",
|
||||
" ()\n",
|
||||
" (1, ())\n",
|
||||
|
|
@ -85,39 +87,36 @@
|
|||
" (3, (2, (1, ())))\n",
|
||||
" ...\n",
|
||||
"\n",
|
||||
"And so on.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"We have two very simple functions to build up a stack from a Python\n",
|
||||
"iterable and also to iterate through a stack and yield its items\n",
|
||||
"one-by-one in order, and two functions to generate string representations\n",
|
||||
"of stacks:\n",
|
||||
"\n",
|
||||
" list_to_stack()\n",
|
||||
"\n",
|
||||
" iter_stack()\n",
|
||||
"\n",
|
||||
" expression_to_string() (prints left-to-right)\n",
|
||||
"\n",
|
||||
" stack_to_string() (prints right-to-left)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"A word about the stack data structure.\n",
|
||||
"\n",
|
||||
"Python has very nice \"tuple packing and unpacking\" in its syntax which\n",
|
||||
"means we can directly \"unpack\" the expected arguments to a Joy function.\n",
|
||||
"\n",
|
||||
"For example:\n",
|
||||
"For example::\n",
|
||||
"\n",
|
||||
" def dup((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",
|
||||
" def dup(stack):\n",
|
||||
" head, tail = stack\n",
|
||||
" return head, (head, tail)\n",
|
||||
"\n",
|
||||
"We replace the argument \"stack\" by the expected structure of the stack,\n",
|
||||
"in this case \"(head, tail)\", and Python takes care of de-structuring the\n",
|
||||
"incoming argument and assigning values to the names. Note that Python\n",
|
||||
"syntax doesn't require parentheses around tuples used in expressions\n",
|
||||
"where they would be redundant.\n"
|
||||
"\n",
|
||||
"We have two very simple functions, one to build up a stack from a Python\n",
|
||||
"iterable and another to iterate through a stack and yield its items\n",
|
||||
"one-by-one in order. There are also two functions to generate string representations\n",
|
||||
"of stacks. They only differ in that one prints the terms in stack from left-to-right while the other prints from right-to-left. In both functions *internal stacks* are\n",
|
||||
"printed left-to-right. These functions are written to support :doc:`../pretty`.\n",
|
||||
"\n",
|
||||
".. _cons list: https://en.wikipedia.org/wiki/Cons#Lists\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -237,22 +236,36 @@
|
|||
"output_type": "stream",
|
||||
"text": [
|
||||
"def joy(stack, expression, dictionary, viewer=None):\n",
|
||||
" '''\n",
|
||||
" Evaluate the Joy expression on the stack.\n",
|
||||
" '''\n",
|
||||
" while expression:\n",
|
||||
"\t'''Evaluate a Joy expression on a stack.\n",
|
||||
"\n",
|
||||
" if viewer: viewer(stack, expression)\n",
|
||||
"\tThis function iterates through a sequence of terms which are either\n",
|
||||
"\tliterals (strings, numbers, sequences of terms) or function symbols.\n",
|
||||
"\tLiterals are put onto the stack and functions are looked up in the\n",
|
||||
"\tdisctionary and executed.\n",
|
||||
"\n",
|
||||
" term, expression = expression\n",
|
||||
" if isinstance(term, Symbol):\n",
|
||||
" term = dictionary[term]\n",
|
||||
" stack, expression, dictionary = term(stack, expression, dictionary)\n",
|
||||
" else:\n",
|
||||
" stack = term, stack\n",
|
||||
"\tThe viewer is a function that is called with the stack and expression\n",
|
||||
"\ton every iteration, its return value is ignored.\n",
|
||||
"\n",
|
||||
" if viewer: viewer(stack, expression)\n",
|
||||
" return stack, expression, dictionary\n",
|
||||
"\t:param stack stack: The stack.\n",
|
||||
"\t:param stack expression: The expression to evaluate.\n",
|
||||
"\t:param dict dictionary: A ``dict`` mapping names to Joy functions.\n",
|
||||
"\t:param function viewer: Optional viewer function.\n",
|
||||
"\t:rtype: (stack, (), dictionary)\n",
|
||||
"\n",
|
||||
"\t'''\n",
|
||||
"\twhile expression:\n",
|
||||
"\n",
|
||||
"\t\tif viewer: viewer(stack, expression)\n",
|
||||
"\n",
|
||||
"\t\tterm, expression = expression\n",
|
||||
"\t\tif isinstance(term, Symbol):\n",
|
||||
"\t\t\tterm = dictionary[term]\n",
|
||||
"\t\t\tstack, expression, dictionary = term(stack, expression, dictionary)\n",
|
||||
"\t\telse:\n",
|
||||
"\t\t\tstack = term, stack\n",
|
||||
"\n",
|
||||
"\tif viewer: viewer(stack, expression)\n",
|
||||
"\treturn stack, expression, dictionary\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
|
|
@ -304,19 +317,22 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"§ Converting text to a joy expression.\n",
|
||||
"This module exports a single function for converting text to a joy\n",
|
||||
"expression as well as a single Symbol class and a single Exception type.\n",
|
||||
"\n",
|
||||
"This module exports a single function:\n",
|
||||
"The Symbol string class is used by the interpreter to recognize literals\n",
|
||||
"by the fact that they are not Symbol objects.\n",
|
||||
"\n",
|
||||
" text_to_expression(text)\n",
|
||||
"A crude grammar::\n",
|
||||
"\n",
|
||||
"As well as a single Symbol class and a single Exception type:\n",
|
||||
" joy = term*\n",
|
||||
" term = int | float | string | '[' joy ']' | symbol\n",
|
||||
"\n",
|
||||
" ParseError\n",
|
||||
"\n",
|
||||
"When supplied with a string this function returns a Python datastructure\n",
|
||||
"that represents the Joy datastructure described by the text expression.\n",
|
||||
"Any unbalanced square brackets will raise a ParseError.\n"
|
||||
"A Joy expression is a sequence of zero or more terms. A term is a\n",
|
||||
"literal value (integer, float, string, or Joy expression) or a function\n",
|
||||
"symbol. Function symbols are unquoted strings and cannot contain square\n",
|
||||
"brackets. Terms must be separated by blanks, which can be omitted\n",
|
||||
"around square brackets.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -343,27 +359,27 @@
|
|||
"output_type": "stream",
|
||||
"text": [
|
||||
"def _parse(tokens):\n",
|
||||
" '''\n",
|
||||
" Return a stack/list expression of the tokens.\n",
|
||||
" '''\n",
|
||||
" frame = []\n",
|
||||
" stack = []\n",
|
||||
" for tok in tokens:\n",
|
||||
" if tok == '[':\n",
|
||||
" stack.append(frame)\n",
|
||||
" frame = []\n",
|
||||
" stack[-1].append(frame)\n",
|
||||
" elif tok == ']':\n",
|
||||
" try:\n",
|
||||
" frame = stack.pop()\n",
|
||||
" except IndexError:\n",
|
||||
" raise ParseError('One or more extra closing brackets.')\n",
|
||||
" frame[-1] = list_to_stack(frame[-1])\n",
|
||||
" else:\n",
|
||||
" frame.append(tok)\n",
|
||||
" if stack:\n",
|
||||
" raise ParseError('One or more unclosed brackets.')\n",
|
||||
" return list_to_stack(frame)\n",
|
||||
"\t'''\n",
|
||||
"\tReturn a stack/list expression of the tokens.\n",
|
||||
"\t'''\n",
|
||||
"\tframe = []\n",
|
||||
"\tstack = []\n",
|
||||
"\tfor tok in tokens:\n",
|
||||
"\t\tif tok == '[':\n",
|
||||
"\t\t\tstack.append(frame)\n",
|
||||
"\t\t\tframe = []\n",
|
||||
"\t\t\tstack[-1].append(frame)\n",
|
||||
"\t\telif tok == ']':\n",
|
||||
"\t\t\ttry:\n",
|
||||
"\t\t\t\tframe = stack.pop()\n",
|
||||
"\t\t\texcept IndexError:\n",
|
||||
"\t\t\t\traise ParseError('Extra closing bracket.')\n",
|
||||
"\t\t\tframe[-1] = list_to_stack(frame[-1])\n",
|
||||
"\t\telse:\n",
|
||||
"\t\t\tframe.append(tok)\n",
|
||||
"\tif stack:\n",
|
||||
"\t\traise ParseError('Unclosed bracket.')\n",
|
||||
"\treturn list_to_stack(frame)\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
|
|
@ -498,7 +514,7 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"!= % & * *fraction *fraction0 + ++ - -- / < << <= <> = > >= >> ? ^ add anamorphism and app1 app2 app3 average b binary branch choice clear cleave concat cons dinfrirst dip dipd dipdd disenstacken div down_to_zero dudipd dup dupd dupdip enstacken eq first flatten floordiv gcd ge genrec getitem gt help i id ifte infra le least_fraction loop lshift lt map min mod modulus mul ne neg not nullary or over pam parse pm pop popd popdd popop pow pred primrec product quoted range range_to_zero rem remainder remove rest reverse roll< roll> rolldown rollup rshift run second select sharing shunt size sqr sqrt stack step sub succ sum swaack swap swoncat swons ternary third times truediv truthy tuck unary uncons unit unquoted unstack void warranty while words x xor zip •\n"
|
||||
"!= % & * *fraction *fraction0 + ++ - -- / // /floor < << <= <> = > >= >> ? ^ _Tree_add_Ee _Tree_delete_R0 _Tree_delete_clear_stuff _Tree_get_E abs add anamorphism and app1 app2 app3 at average b binary bool branch ccons choice clear cleave cmp codireco concat cond cons dinfrirst dip dipd dipdd disenstacken divmod down_to_zero drop dup dupd dupdd dupdip dupdipd enstacken eq first first_two flatten floor floordiv fork fourth gcd ge genrec getitem gt help i id ifte ii infer infra inscribe le least_fraction loop lshift lt make_generator map max min mod modulus mul ne neg not nullary of or over pam parse pick pm pop popd popdd popop popopd popopdd pow pred primrec product quoted range range_to_zero rem remainder remove rest reverse roll< roll> rolldown rollup round rrest rshift run second select sharing shunt size sort sqr sqrt stack step step_zero stuncons stununcons sub succ sum swaack swap swons take ternary third times truediv truthy tuck unary uncons unique unit unquoted unstack unswons void warranty while words x xor zip •\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
@ -524,10 +540,24 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"@inscribe\n",
|
||||
"@combinator_effect(_COMB_NUMS(), a1, s1)\n",
|
||||
"@FunctionWrapper\n",
|
||||
"def dip(stack, expression, dictionary):\n",
|
||||
" (quote, (x, stack)) = stack\n",
|
||||
" expression = x, expression\n",
|
||||
" return stack, pushback(quote, expression), dictionary\n",
|
||||
"\t'''\n",
|
||||
"\tThe dip combinator expects a quoted program on the stack and below it\n",
|
||||
"\tsome item, it hoists the item into the expression and runs the program\n",
|
||||
"\ton the rest of the stack.\n",
|
||||
"\t::\n",
|
||||
"\n",
|
||||
"\t\t\t ... x [Q] dip\n",
|
||||
"\t\t-------------------\n",
|
||||
"\t\t\t\t ... Q x\n",
|
||||
"\n",
|
||||
"\t'''\n",
|
||||
"\t(quote, (x, stack)) = stack\n",
|
||||
"\texpression = (x, expression)\n",
|
||||
"\treturn stack, concat(quote, expression), dictionary\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
|
|
@ -552,28 +582,26 @@
|
|||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"second == rest first\n",
|
||||
"third == rest rest first\n",
|
||||
"ii == [dip] dupdip i\n",
|
||||
"of == swap at\n",
|
||||
"product == 1 swap [*] step\n",
|
||||
"swons == swap cons\n",
|
||||
"swoncat == swap concat\n",
|
||||
"flatten == [] swap [concat] step\n",
|
||||
"unit == [] cons\n",
|
||||
"quoted == [unit] dip\n",
|
||||
"unquoted == [i] dip\n",
|
||||
"enstacken == stack [clear] dip\n",
|
||||
"disenstacken == ? [uncons ?] loop pop\n",
|
||||
"? == dup truthy\n",
|
||||
"disenstacken == ? [uncons ?] loop pop\n",
|
||||
"dinfrirst == dip infra first\n",
|
||||
"nullary == [stack] dinfrirst\n",
|
||||
"unary == [stack [pop] dip] dinfrirst\n",
|
||||
"binary == [stack [popop] dip] dinfrirst\n",
|
||||
"ternary == [stack [popop pop] dip] dinfrirst\n",
|
||||
"unary == nullary popd\n",
|
||||
"binary == nullary [popop] dip\n",
|
||||
"ternary == unary [popop] dip\n",
|
||||
"pam == [i] map\n",
|
||||
"run == [] swap infra\n",
|
||||
"sqr == dup mul\n",
|
||||
"size == 0 swap [pop ++] step\n",
|
||||
"cleave == [i] app2 [popd] dip\n",
|
||||
"fork == [i] app2\n",
|
||||
"cleave == fork [popd] dip\n",
|
||||
"average == [sum 1.0 *] [size] cleave /\n",
|
||||
"gcd == 1 [tuck modulus dup 0 >] loop pop\n",
|
||||
"least_fraction == dup [gcd] infra [div] concat map\n",
|
||||
|
|
@ -584,8 +612,12 @@
|
|||
"anamorphism == [pop []] swap [dip swons] genrec\n",
|
||||
"range == [0 <=] [1 - dup] anamorphism\n",
|
||||
"while == swap [nullary] cons dup dipd concat loop\n",
|
||||
"dudipd == dup dipd\n",
|
||||
"dupdipd == dup dipd\n",
|
||||
"primrec == [i] genrec\n",
|
||||
"step_zero == 0 roll> step\n",
|
||||
"codireco == cons dip rest cons\n",
|
||||
"make_generator == [codireco] ccons\n",
|
||||
"ifte == [nullary not] dipd branch\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -214,6 +214,13 @@
|
|||
"source": [
|
||||
"V('96 27 gcd')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -11773,7 +11773,7 @@ div#notebook {
|
|||
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [1]:</div>
|
||||
<div class="prompt input_prompt">In [2]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="kn">import</span> <span class="n">D</span><span class="p">,</span> <span class="n">DefinitionWrapper</span><span class="p">,</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span><span class="p">,</span> <span class="n">define</span>
|
||||
|
|
@ -11789,6 +11789,7 @@ div#notebook {
|
|||
<div class="inner_cell">
|
||||
<div class="text_cell_render border-box-sizing rendered_html">
|
||||
<h1 id="On-"Two-Exercises-Found-in-a-Book-on-Algorithmics"">On "Two Exercises Found in a Book on Algorithmics"<a class="anchor-link" href="#On-"Two-Exercises-Found-in-a-Book-on-Algorithmics"">¶</a></h1><p>Bird & Meertens</p>
|
||||
<p><a href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614">PDF paper available here</a></p>
|
||||
|
||||
</div>
|
||||
</div>
|
||||
|
|
@ -11806,7 +11807,7 @@ div#notebook {
|
|||
<blockquote><p>The problem is to find some definition of <code>scan</code> as a reduction. In other words, we have to find some function <code>f</code> and an operator <code>⨂</code> so that</p>
|
||||
</blockquote>
|
||||
|
||||
<pre><code>⨂\x = f(a)⨂f(b)⨂...⨂f(z)</code></pre>
|
||||
<pre><code>⨁\x = f(a)⨂f(b)⨂...⨂f(z)</code></pre>
|
||||
|
||||
</div>
|
||||
</div>
|
||||
|
|
@ -11941,7 +11942,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [2]:</div>
|
||||
<div class="prompt input_prompt">In [3]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3] [size 1 <=] [pop []] [[[+] infra] dupdip first] [dip swons] genrec'</span><span class="p">)</span>
|
||||
|
|
@ -11981,7 +11982,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [3]:</div>
|
||||
<div class="prompt input_prompt">In [4]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3] [size 1 <=] [[]] [[[+] infra] dupdip first] [dip swons] genrec'</span><span class="p">)</span>
|
||||
|
|
@ -12021,7 +12022,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [4]:</div>
|
||||
<div class="prompt input_prompt">In [5]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3] [size 1 <=] [] [[[+] infra] dupdip first] [dip swons] genrec'</span><span class="p">)</span>
|
||||
|
|
@ -12076,7 +12077,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [5]:</div>
|
||||
<div class="prompt input_prompt">In [6]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'scan == [infra] cons [dupdip first] cons [size 1 <=] [] roll< [dip swons] genrec'</span><span class="p">)</span>
|
||||
|
|
@ -12089,7 +12090,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [6]:</div>
|
||||
<div class="prompt input_prompt">In [7]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3 4] [+] scan'</span><span class="p">)</span>
|
||||
|
|
@ -12120,7 +12121,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [7]:</div>
|
||||
<div class="prompt input_prompt">In [8]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3 4] [*] scan'</span><span class="p">)</span>
|
||||
|
|
@ -12151,7 +12152,7 @@ scan == [size 1 <=] [pop []] [[[F] infra] dupdip first] [dip swons] genrec</c
|
|||
</div>
|
||||
<div class="cell border-box-sizing code_cell rendered">
|
||||
<div class="input">
|
||||
<div class="prompt input_prompt">In [8]:</div>
|
||||
<div class="prompt input_prompt">In [9]:</div>
|
||||
<div class="inner_cell">
|
||||
<div class="input_area">
|
||||
<div class=" highlight hl-ipython2"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[1 2 3 4 5 6 7] [neg +] scan'</span><span class="p">)</span>
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ from notebook_preamble import D, DefinitionWrapper, J, V, define
|
|||
|
||||
Bird & Meertens
|
||||
|
||||
[PDF paper available here](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614)
|
||||
|
||||
## Define `scan` in terms of a reduction.
|
||||
|
||||
> Problem I. The reduction operator `/` of APL takes some binary operator `⨁` on its left and a vector `x` of values on its right. The meaning of `⨁/x` for `x = [a b ... z]` is the value `a⨁b⨁...⨁z`. For this to be well-defined in the absence of brackets, the operation `⨁` has to be associative. Now there is another operator `\` of APL called `scan`. Its effect is closely related to reduction in that we have:
|
||||
|
|
@ -16,7 +18,7 @@ Bird & Meertens
|
|||
|
||||
> The problem is to find some definition of `scan` as a reduction. In other words, we have to find some function `f` and an operator `⨂` so that
|
||||
|
||||
⨂\x = f(a)⨂f(b)⨂...⨂f(z)
|
||||
⨁\x = f(a)⨂f(b)⨂...⨂f(z)
|
||||
|
||||
## Designing the Recursive Function
|
||||
Ignoring the exact requirements (finding `f` and `⨂`) can we implement `scan` as a hylomorphism in Joy?
|
||||
|
|
|
|||
|
|
@ -8,6 +8,9 @@ On "Two Exercises Found in a Book on Algorithmics"
|
|||
|
||||
Bird & Meertens
|
||||
|
||||
`PDF paper available
|
||||
here <https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.694.2614>`__
|
||||
|
||||
Define ``scan`` in terms of a reduction.
|
||||
----------------------------------------
|
||||
|
||||
|
|
@ -29,7 +32,7 @@ Define ``scan`` in terms of a reduction.
|
|||
|
||||
::
|
||||
|
||||
⨂\x = f(a)⨂f(b)⨂...⨂f(z)
|
||||
⨁\x = f(a)⨂f(b)⨂...⨂f(z)
|
||||
|
||||
Designing the Recursive Function
|
||||
--------------------------------
|
||||
|
|
|
|||
|
|
@ -36,7 +36,6 @@
|
|||
<li><a href="joy/library.html">joy.library</a></li>
|
||||
<li><a href="joy/parser.html">joy.parser</a></li>
|
||||
<li><a href="joy/utils/generated_library.html">joy.utils.generated_library</a></li>
|
||||
<li><a href="joy/utils/polytypes.html">joy.utils.polytypes</a></li>
|
||||
<li><a href="joy/utils/pretty_print.html">joy.utils.pretty_print</a></li>
|
||||
<li><a href="joy/utils/stack.html">joy.utils.stack</a></li>
|
||||
<li><a href="joy/utils/types.html">joy.utils.types</a></li>
|
||||
|
|
|
|||
|
|
@ -57,10 +57,7 @@
|
|||
|
||||
<span class="sd">'''</span>
|
||||
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
|
||||
<span class="k">try</span><span class="p">:</span>
|
||||
<span class="nb">input</span> <span class="o">=</span> <span class="n">raw_input</span>
|
||||
<span class="k">except</span> <span class="ne">NameError</span><span class="p">:</span>
|
||||
<span class="k">pass</span>
|
||||
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">input</span>
|
||||
<span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="p">,</span> <span class="n">format_exc</span>
|
||||
<span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">ParseError</span><span class="p">,</span> <span class="n">Symbol</span>
|
||||
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">stack_to_string</span>
|
||||
|
|
@ -68,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>
|
||||
<span class="sd">'''Evaluate the Joy expression on the stack.</span>
|
||||
<span class="sd"> </span>
|
||||
<span class="sd"> The basic joy() function is quite straightforward. It iterates through a</span>
|
||||
<span class="sd"> sequence of terms which are either literals (strings, numbers, sequences)</span>
|
||||
<span class="sd"> or functions. Literals are put onto the stack and functions are</span>
|
||||
<span class="sd"> executed.</span>
|
||||
<span class="sd">'''Evaluate a Joy expression on a stack.</span>
|
||||
|
||||
<span class="sd"> This function iterates through a sequence of terms which are either</span>
|
||||
<span class="sd"> literals (strings, numbers, sequences of terms) or function symbols.</span>
|
||||
<span class="sd"> Literals are put onto the stack and functions are looked up in the</span>
|
||||
<span class="sd"> disctionary and executed.</span>
|
||||
|
||||
<span class="sd"> 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 expression: The expression to evaluate.</span>
|
||||
|
|
|
|||
|
|
@ -56,18 +56,86 @@
|
|||
<span class="sd">returns a dictionary of Joy functions suitable for use with the joy()</span>
|
||||
<span class="sd">function.</span>
|
||||
<span class="sd">'''</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">'Loading library.'</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">functools</span> <span class="k">import</span> <span class="n">wraps</span>
|
||||
<span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">count</span>
|
||||
<span class="kn">from</span> <span class="nn">inspect</span> <span class="k">import</span> <span class="n">getmembers</span><span class="p">,</span> <span class="n">isfunction</span>
|
||||
<span class="kn">import</span> <span class="nn">operator</span><span class="o">,</span> <span class="nn">math</span>
|
||||
|
||||
<span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">Symbol</span>
|
||||
<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">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"><</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.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>
|
||||
|
||||
|
||||
|
|
@ -87,6 +155,8 @@
|
|||
<span class="p">(</span><span class="s1">'and'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'&'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'bool'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'truthy'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'mul'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'*'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'floordiv'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'/floor'</span><span class="p">,</span> <span class="s1">'//'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'floor'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'round'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'truediv'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'/'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'mod'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'%'</span><span class="p">,</span> <span class="s1">'rem'</span><span class="p">,</span> <span class="s1">'remainder'</span><span class="p">,</span> <span class="s1">'modulus'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'eq'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'='</span><span class="p">]),</span>
|
||||
|
|
@ -104,6 +174,7 @@
|
|||
<span class="p">(</span><span class="s1">'pred'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'--'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'rolldown'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'roll<'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'rollup'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'roll>'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'eh'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'?'</span><span class="p">]),</span>
|
||||
<span class="p">(</span><span class="s1">'id'</span><span class="p">,</span> <span class="p">[</span><span class="sa">u</span><span class="s1">'•'</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>
|
||||
|
||||
|
||||
<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">'''</span>
|
||||
<span class="sd"> Return a dict of named stack effects.</span>
|
||||
|
||||
<span class="sd"> "Yin" 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"> '''</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">'''</span><span class="se">\</span>
|
||||
<span class="s1">ii == [dip] dupdip i</span>
|
||||
<span class="s1">of == swap at</span>
|
||||
<span class="s1">product == 1 swap [*] step</span>
|
||||
<span class="s1">flatten == [] swap [concat] step</span>
|
||||
<span class="s1">quoted == [unit] dip</span>
|
||||
<span class="s1">unquoted == [i] 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">disenstacken == ? [uncons ?] loop pop</span>
|
||||
<span class="s1">dinfrirst == dip infra first</span>
|
||||
<span class="s1">nullary == [stack] dinfrirst</span>
|
||||
<span class="s1">unary == nullary popd</span>
|
||||
|
|
@ -161,6 +283,7 @@
|
|||
<span class="s1">ifte == [nullary not] dipd branch</span>
|
||||
<span class="s1">'''</span>
|
||||
<span class="c1">#</span>
|
||||
<span class="c1">#</span>
|
||||
<span class="c1"># ifte == [nullary] dipd swap branch</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">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="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>
|
||||
|
||||
<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">'''</span>
|
||||
<span class="sd"> Add the definition to the dictionary.</span>
|
||||
<span class="sd"> '''</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">'Adding definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">'</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">'=='</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>
|
||||
|
|
@ -306,9 +437,23 @@
|
|||
<span class="c1">#</span>
|
||||
|
||||
|
||||
<span class="c1"># Load the auto-generated primitives into the dictionary.</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>
|
||||
<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="nd">@sec0</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">'''</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"> '''</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>
|
||||
|
|
@ -320,7 +465,18 @@
|
|||
<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">'''Attempt to infer the stack effect of a Joy expression.'''</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>
|
||||
<span class="nd">@sec2</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="sd">'''</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>
|
||||
<span class="nd">@sec1</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="sd">'''</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>
|
||||
<span class="nd">@sec1</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="sd">'''</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>
|
||||
<span class="nd">@sec_Ns_math</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="sd">'''Given a list find the maximum.'''</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>
|
||||
<span class="nd">@sec_Ns_math</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="sd">'''Given a list find the minimum.'''</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>
|
||||
<span class="nd">@sec_Ns_math</span>
|
||||
<span class="nd">@SimpleFunctionWrapper</span>
|
||||
<span class="k">def</span> <span class="nf">sum_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
|
||||
<span class="sd">'''Given a quoted sequence of numbers return the sum.</span>
|
||||
|
|
@ -494,7 +655,6 @@
|
|||
<span class="sd">'''Given a list remove duplicate items.'''</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">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>
|
||||
|
||||
|
||||
|
|
@ -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="n">_functions</span><span class="p">[</span><span class="s1">'clear'</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>
|
||||
<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>
|
||||
|
|
@ -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>
|
||||
<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="k">def</span> <span class="nf">concat_</span><span class="p">(</span><span class="n">S</span><span class="p">):</span>
|
||||
<span class="sd">'''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>
|
||||
<span class="nd">@sec_unary_math</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="sd">'''Increment TOS.'''</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>
|
||||
<span class="nd">@sec_unary_math</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="sd">'''Decrement TOS.'''</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">'i'</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">'ifte'</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">'infra'</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">'pop'</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">'step'</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">'times'</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">'swaack'</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">'truthy'</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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"> ... [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>
|
||||
<span class="c1">#@combinator_effect(_COMB_NUMS(), s7, s6, s5, s4)</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="sd">'''</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>
|
||||
<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="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">'''</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"> '''</span>
|
||||
<span class="c1"># (quote, (aggregate, stack)) = S</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="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>
|
||||
<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="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">'''</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="c1">#FUNCTIONS['branch'] = CombinatorJoyType('branch', [branch_true, branch_false], 100)</span>
|
||||
|
||||
|
||||
<span class="c1">##@inscribe</span>
|
||||
<span class="c1">##@FunctionWrapper</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''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>
|
||||
<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="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">'''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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</span>
|
||||
|
|
@ -1261,7 +1456,21 @@
|
|||
<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>
|
||||
<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="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">'''</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>
|
||||
<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="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">'''</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="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="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">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">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">operator</span><span class="o">.</span><span class="n">not_</span><span class="p">),</span>
|
||||
<span class="n">UnaryBuiltinWrapper</span><span class="p">(</span><span class="n">sqrt</span><span class="p">),</span>
|
||||
<span class="c1">#divmod_ = pm = __(n2, n1), __(n4, n3)</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">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">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">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="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="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 '''</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"># ''' 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">'Setting stack effect for Yin function </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">'</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">_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">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">'while'</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">'''</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"> '''</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">'Setting stack EXPECT for combinator </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">'</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">'combinator </span><span class="si">%s</span><span class="s1">'</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">'''</span>
|
||||
<span class="s1"> of quoted enstacken ?</span>
|
||||
<span class="s1"> unary binary ternary</span>
|
||||
<span class="s1"> sqr unquoted</span>
|
||||
<span class="s1"> '''</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">'Setting stack effect for definition </span><span class="si">%s</span><span class="s1"> := </span><span class="si">%s</span><span class="s1">'</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['product'])</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 >] 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 >] [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 <=] [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> 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>
|
||||
|
||||
</div>
|
||||
|
|
|
|||
|
|
@ -60,17 +60,29 @@
|
|||
<span class="sd">A crude grammar::</span>
|
||||
|
||||
<span class="sd"> joy = term*</span>
|
||||
<span class="sd"> term = int | float | string | '[' joy ']' | function</span>
|
||||
|
||||
<span class="sd">A Joy expression is a sequence of zero or more terms</span>
|
||||
<span class="sd"> term = int | float | string | '[' joy ']' | symbol</span>
|
||||
|
||||
<span class="sd">A Joy expression is a sequence of zero or more terms. A term is a</span>
|
||||
<span class="sd">literal value (integer, float, string, or Joy expression) or a function</span>
|
||||
<span class="sd">symbol. Function symbols are unquoted strings and cannot contain square</span>
|
||||
<span class="sd">brackets. Terms must be separated by blanks, which can be omitted</span>
|
||||
<span class="sd">around square brackets.</span>
|
||||
|
||||
<span class="sd">'''</span>
|
||||
<span class="c1">#TODO: explain the details of float lits and strings.</span>
|
||||
<span class="kn">from</span> <span class="nn">re</span> <span class="k">import</span> <span class="n">Scanner</span>
|
||||
<span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">list_to_stack</span>
|
||||
|
||||
|
||||
<span class="c1">#TODO: explain the details of float lits and strings.</span>
|
||||
<span class="n">FLOAT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'-?\d+\.\d*'</span>
|
||||
<span class="n">INT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'-?\d+'</span>
|
||||
<span class="n">SYMBOL</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'[•\w!@$%^&*()_+<>?|\/;:`~,.=-]+'</span>
|
||||
<span class="n">BRACKETS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'\[|\]'</span>
|
||||
<span class="n">STRING_DOUBLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'"(?:[^"</span><span class="se">\\</span><span class="s1">]|</span><span class="se">\\</span><span class="s1">.)*"'</span>
|
||||
<span class="n">STRING_SINGLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s2">"'(?:[^'</span><span class="se">\\</span><span class="s2">]|</span><span class="se">\\</span><span class="s2">.)*'"</span>
|
||||
<span class="n">BLANKS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">'\s+'</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">'''A string class that represents Joy function names.'''</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>
|
||||
|
|
@ -135,13 +147,13 @@
|
|||
|
||||
|
||||
<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">'-?\d+\.\d*'</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">'-?\d+'</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">'[•\w!@$%^&*()_+<>?|\/;:`~,.=-]+'</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">'\[|\]'</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">'"(?:[^"</span><span class="se">\\</span><span class="s1">]|</span><span class="se">\\</span><span class="s1">.)*"'</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">'</span><span class="se">\\</span><span class="s1">"'</span><span class="p">,</span> <span class="s1">'"'</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="sa">r</span><span class="s2">"'(?:[^'</span><span class="se">\\</span><span class="s2">]|</span><span class="se">\\</span><span class="s2">.)*'"</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">"</span><span class="se">\\</span><span class="s2">'"</span><span class="p">,</span> <span class="s2">"'"</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="sa">r</span><span class="s1">'\s+'</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
|
||||
<span class="p">(</span><span class="n">FLOAT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="n">INT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="n">SYMBOL</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">Symbol</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="n">BRACKETS</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span>
|
||||
<span class="p">(</span><span class="n">STRING_DOUBLE_QUOTED</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">'</span><span class="se">\\</span><span class="s1">"'</span><span class="p">,</span> <span class="s1">'"'</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">"</span><span class="se">\\</span><span class="s2">'"</span><span class="p">,</span> <span class="s2">"'"</span><span class="p">)),</span>
|
||||
<span class="p">(</span><span class="n">BLANKS</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
|
||||
<span class="p">])</span>
|
||||
</pre></div>
|
||||
|
||||
|
|
|
|||
|
|
@ -73,6 +73,7 @@
|
|||
<span class="c1"># (Kinda clunky and hacky. This should be swapped out in favor of much</span>
|
||||
<span class="c1"># smarter stuff.)</span>
|
||||
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
|
||||
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">object</span>
|
||||
<span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span>
|
||||
<span class="kn">from</span> <span class="nn">.stack</span> <span class="k">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">stack_to_string</span>
|
||||
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@
|
|||
<span class="sd">'''</span>
|
||||
|
||||
|
||||
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span>
|
||||
<div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span>
|
||||
<span class="sd">'''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">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">'L'</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">''</span> <span class="c1"># shortcut</span>
|
||||
<span class="k">return</span> <span class="s1">' '</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="s1">'[</span><span class="si">%s</span><span class="s1">]'</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">'L'</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">long</span><span class="p">)</span>
|
||||
<span class="k">else</span> <span class="nb">repr</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
|
||||
<span class="p">)</span>
|
||||
|
||||
|
|
@ -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">'''</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"> :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"> '''</span>
|
||||
<span class="k">if</span> <span class="n">n</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
|
||||
<span class="k">raise</span> <span class="ne">ValueError</span>
|
||||
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
|
||||
<span class="k">try</span><span class="p">:</span>
|
||||
<span class="n">item</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">s</span>
|
||||
<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
|
||||
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
|
||||
<span class="k">raise</span> <span class="ne">IndexError</span>
|
||||
<span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
|
||||
|
|
|
|||
|
|
@ -58,6 +58,7 @@
|
|||
| <a href="#V"><strong>V</strong></a>
|
||||
| <a href="#W"><strong>W</strong></a>
|
||||
| <a href="#X"><strong>X</strong></a>
|
||||
| <a href="#Y"><strong>Y</strong></a>
|
||||
| <a href="#Z"><strong>Z</strong></a>
|
||||
|
||||
</div>
|
||||
|
|
@ -72,6 +73,8 @@
|
|||
<li><a href="types.html#joy.utils.types.IntJoyType.accept">(joy.utils.types.IntJoyType attribute)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.StackJoyType.accept">(joy.utils.types.StackJoyType attribute)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.TextJoyType.accept">(joy.utils.types.TextJoyType attribute)</a>
|
||||
</li>
|
||||
</ul></li>
|
||||
<li><a href="library.html#joy.library.add_aliases">add_aliases() (in module joy.library)</a>
|
||||
|
|
@ -120,7 +123,7 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.library.cmp_">cmp_() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.CombinatorJoyType">CombinatorJoyType (class in joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.CombinatorJoyType">CombinatorJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.compilable">compilable() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
|
|
@ -128,12 +131,8 @@
|
|||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#joy.utils.types.compile_">compile_() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.compose">compose() (in module joy.utils.polytypes)</a>
|
||||
|
||||
<ul>
|
||||
<li><a href="types.html#joy.utils.types.compose">(in module joy.utils.types)</a>
|
||||
<li><a href="types.html#joy.utils.types.compose">compose() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></li>
|
||||
<li><a href="stack.html#joy.utils.stack.concat">concat() (in module joy.utils.stack)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.concat_">concat_() (in module joy.library)</a>
|
||||
|
|
@ -150,12 +149,6 @@
|
|||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="library.html#joy.library.DefinitionWrapper">DefinitionWrapper (class in joy.library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.defs">defs() (in module joy.utils.polytypes)</a>
|
||||
|
||||
<ul>
|
||||
<li><a href="types.html#joy.utils.types.defs">(in module joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></li>
|
||||
<li><a href="types.html#joy.utils.types.delabel">delabel() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.dip">dip() (in module joy.library)</a>
|
||||
|
|
@ -164,10 +157,10 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.library.dipdd">dipdd() (in module joy.library)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="library.html#joy.library.divmod_">divmod_() (in module joy.library)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#joy.utils.types.doc_from_stack_effect">doc_from_stack_effect() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.drop">drop() (in module joy.library)</a>
|
||||
|
|
@ -199,16 +192,14 @@
|
|||
<li><a href="library.html#joy.utils.generated_library.first_two">first_two() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.FloatJoyType">FloatJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.floor">floor() (in module joy.library)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="library.html#joy.library.floor">floor() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.fourth">fourth() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.FunctionJoyType">FunctionJoyType (class in joy.utils.polytypes)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.FUNCTIONS">FUNCTIONS (in module joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.FunctionJoyType">FunctionJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.FunctionWrapper">FunctionWrapper() (in module joy.library)</a>
|
||||
</li>
|
||||
|
|
@ -244,7 +235,9 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.library.id_">id_() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.infer">infer() (in module joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.infer">infer() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.infer_">infer_() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.infra">infra() (in module joy.library)</a>
|
||||
</li>
|
||||
|
|
@ -254,12 +247,10 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.library.inscribe">inscribe() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.IntJoyType">IntJoyType (class in joy.utils.polytypes)</a>
|
||||
|
||||
<ul>
|
||||
<li><a href="types.html#joy.utils.types.IntJoyType">(class in joy.utils.types)</a>
|
||||
<li><a href="library.html#joy.library.inscribe_">inscribe_() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.IntJoyType">IntJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></li>
|
||||
<li><a href="stack.html#joy.utils.stack.iter_stack">iter_stack() (in module joy.utils.stack)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
|
|
@ -275,12 +266,10 @@
|
|||
<li><a href="library.html#module-joy.library">joy.library (module)</a>
|
||||
</li>
|
||||
<li><a href="parser.html#module-joy.parser">joy.parser (module)</a>
|
||||
</li>
|
||||
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#module-joy.utils.polytypes">joy.utils.polytypes (module)</a>
|
||||
<li><a href="library.html#module-joy.utils.generated_library">joy.utils.generated_library (module)</a>
|
||||
</li>
|
||||
<li><a href="pretty.html#module-joy.utils.pretty_print">joy.utils.pretty_print (module)</a>
|
||||
</li>
|
||||
|
|
@ -296,11 +285,11 @@
|
|||
<h2 id="K">K</h2>
|
||||
<table style="width: 100%" class="indextable genindextable"><tr>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#joy.utils.polytypes.KleeneStar.kind">kind (joy.utils.polytypes.KleeneStar attribute)</a>
|
||||
<li><a href="types.html#joy.utils.types.KleeneStar.kind">kind (joy.utils.types.KleeneStar attribute)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#joy.utils.polytypes.KleeneStar">KleeneStar (class in joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.KleeneStar">KleeneStar (class in joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
</tr></table>
|
||||
|
|
@ -326,7 +315,7 @@
|
|||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="types.html#joy.utils.polytypes.meta_compose">meta_compose() (in module joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.meta_compose">meta_compose() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.library.min_">min_() (in module joy.library)</a>
|
||||
</li>
|
||||
|
|
@ -362,10 +351,12 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.library.pm">pm() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.pop">pop() (in module joy.utils.generated_library)</a>
|
||||
<li><a href="types.html#joy.utils.types.poly_compose">poly_compose() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="library.html#joy.utils.generated_library.pop">pop() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.popd">popd() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.popdd">popdd() (in module joy.utils.generated_library)</a>
|
||||
|
|
@ -452,7 +443,7 @@
|
|||
</li>
|
||||
<li><a href="parser.html#joy.parser.Symbol">Symbol (class in joy.parser)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.SymbolJoyType">SymbolJoyType (class in joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.SymbolJoyType">SymbolJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
</tr></table>
|
||||
|
|
@ -463,6 +454,8 @@
|
|||
<li><a href="library.html#joy.library.take">take() (in module joy.library)</a>
|
||||
</li>
|
||||
<li><a href="parser.html#joy.parser.text_to_expression">text_to_expression() (in module joy.parser)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.TextJoyType">TextJoyType (class in joy.utils.types)</a>
|
||||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.third">third() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
|
|
@ -474,7 +467,7 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.tuck">tuck() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.polytypes.type_check">type_check() (in module joy.utils.polytypes)</a>
|
||||
<li><a href="types.html#joy.utils.types.type_check">type_check() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
</tr></table>
|
||||
|
|
@ -486,7 +479,7 @@
|
|||
</li>
|
||||
<li><a href="library.html#joy.utils.generated_library.uncons">uncons() (in module joy.utils.generated_library)</a>
|
||||
</li>
|
||||
<li><a href="types.html#joy.utils.types.unify">unify() (in module joy.utils.types)</a>
|
||||
<li><a href="types.html#joy.utils.types.uni_unify">uni_unify() (in module joy.utils.types)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
|
|
@ -533,6 +526,14 @@
|
|||
</ul></td>
|
||||
</tr></table>
|
||||
|
||||
<h2 id="Y">Y</h2>
|
||||
<table style="width: 100%" class="indextable genindextable"><tr>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
<li><a href="library.html#joy.library.yin_functions">yin_functions() (in module joy.library)</a>
|
||||
</li>
|
||||
</ul></td>
|
||||
</tr></table>
|
||||
|
||||
<h2 id="Z">Z</h2>
|
||||
<table style="width: 100%" class="indextable genindextable"><tr>
|
||||
<td style="width: 33%; vertical-align: top;"><ul>
|
||||
|
|
|
|||
|
|
@ -42,11 +42,13 @@ match the behaviour of the original version(s) written in C.</p>
|
|||
<dl class="function">
|
||||
<dt id="joy.joy.joy">
|
||||
<code class="descclassname">joy.joy.</code><code class="descname">joy</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em>, <em>viewer=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/joy.html#joy"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.joy.joy" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Evaluate the Joy expression on the stack.</p>
|
||||
<p>The basic joy() function is quite straightforward. It iterates through a
|
||||
sequence of terms which are either literals (strings, numbers, sequences)
|
||||
or functions. Literals are put onto the stack and functions are
|
||||
executed.</p>
|
||||
<dd><p>Evaluate a Joy expression on a stack.</p>
|
||||
<p>This function iterates through a sequence of terms which are either
|
||||
literals (strings, numbers, sequences of terms) or function symbols.
|
||||
Literals are put onto the stack and functions are looked up in the
|
||||
disctionary and executed.</p>
|
||||
<p>The viewer is a function that is called with the stack and expression
|
||||
on every iteration, its return value is ignored.</p>
|
||||
<table class="docutils field-list" frame="void" rules="none">
|
||||
<col class="field-name" />
|
||||
<col class="field-body" />
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ function.</p>
|
|||
<dd><p>Provide implementation of defined functions, and some helper methods.</p>
|
||||
<dl class="classmethod">
|
||||
<dt id="joy.library.DefinitionWrapper.add_def">
|
||||
<em class="property">classmethod </em><code class="descname">add_def</code><span class="sig-paren">(</span><em>definition</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#DefinitionWrapper.add_def"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.DefinitionWrapper.add_def" title="Permalink to this definition">¶</a></dt>
|
||||
<em class="property">classmethod </em><code class="descname">add_def</code><span class="sig-paren">(</span><em>definition</em>, <em>dictionary</em>, <em>fail_fails=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#DefinitionWrapper.add_def"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.DefinitionWrapper.add_def" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Add the definition to the dictionary.</p>
|
||||
</dd></dl>
|
||||
|
||||
|
|
@ -287,7 +287,8 @@ on the rest of the stack.</p>
|
|||
<dl class="function">
|
||||
<dt id="joy.library.drop">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">drop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#drop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.drop" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
|
||||
<dd><blockquote>
|
||||
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Expects an integer and a quote on the stack and returns the quote with
|
||||
|
|
@ -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>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div></blockquote>
|
||||
<p>Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
|
|
@ -369,7 +375,8 @@ the original definition in the else-part:</p>
|
|||
<dl class="function">
|
||||
<dt id="joy.library.getitem">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">getitem</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#getitem"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.getitem" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
|
||||
<dd><blockquote>
|
||||
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Expects an integer and a quote on the stack and returns the item at the
|
||||
|
|
@ -379,6 +386,11 @@ nth position in the quote counting from 0.</p>
|
|||
<span class="n">a</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div></blockquote>
|
||||
<p>Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="n">a1</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
|
|
@ -405,11 +417,17 @@ onto the pending expression for evaluation.</p>
|
|||
<dd><p>The identity function.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.infer_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">infer_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infer_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infer_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Attempt to infer the stack effect of a Joy expression.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.infra">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">infra</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infra"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infra" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Accept a quoted program and a list on the stack and run the program
|
||||
with the list as its stack.</p>
|
||||
with the list as its stack. Does not affect the rest of the stack.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
|
||||
<span class="o">-----------------------------</span>
|
||||
<span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
|
||||
|
|
@ -429,6 +447,24 @@ with the list as its stack.</p>
|
|||
<dd><p>A decorator to inscribe functions into the default dictionary.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.inscribe_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">inscribe_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#inscribe_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.inscribe_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><blockquote>
|
||||
<div><p>Create a new Joy function definition in the Joy dictionary. A
|
||||
definition is given as a string with a name followed by a double
|
||||
equal sign then one or more Joy functions, the body. for example:</p>
|
||||
<blockquote>
|
||||
<div>sqr == dup mul</div></blockquote>
|
||||
<p>If you want the definition to persist over restarts, enter it into
|
||||
the definitions.txt resource.</p>
|
||||
</div></blockquote>
|
||||
<p>Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">t1</span> <span class="o">--</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.loop">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">loop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#loop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.loop" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -448,19 +484,27 @@ with the list as its stack.</p>
|
|||
<dt id="joy.library.map_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">map_</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#map_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.map_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Run the quoted program on TOS on the items in the list under it, push a
|
||||
new list with the results (in place of the program and original list.</p>
|
||||
new list with the results in place of the program and original list.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.max_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">max_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#max_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.max_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Given a list find the maximum.</p>
|
||||
<dd><p>Given a list find the maximum.
|
||||
Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.min_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">min_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#min_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.min_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Given a list find the minimum.</p>
|
||||
<dd><p>Given a list find the minimum.
|
||||
Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
|
|
@ -483,7 +527,11 @@ new list with the results (in place of the program and original list.</p>
|
|||
<dl class="function">
|
||||
<dt id="joy.library.pred">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">pred</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pred"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pred" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Decrement TOS.</p>
|
||||
<dd><p>Decrement TOS.
|
||||
Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
|
|
@ -584,20 +632,30 @@ on top of the stack.</p>
|
|||
<dl class="function">
|
||||
<dt id="joy.library.succ">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">succ</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#succ"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.succ" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Increment TOS.</p>
|
||||
<dd><p>Increment TOS.
|
||||
Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.sum_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">sum_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#sum_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.sum_" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Given a quoted sequence of numbers return the sum.</p>
|
||||
<p>sum == 0 swap [+] step</p>
|
||||
<blockquote>
|
||||
<div>sum == 0 swap [+] step</div></blockquote>
|
||||
<p>Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.take">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">take</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#take"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.take" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Expects an integer and a quote on the stack and returns the quote with
|
||||
<dd><blockquote>
|
||||
<div><p>Expects an integer and a quote on the stack and returns the quote with
|
||||
just the top n items in reverse order (because that’s easier and you can
|
||||
use reverse if needed.)</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
|
||||
|
|
@ -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>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div></blockquote>
|
||||
<p>Stack effect:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
|
|
@ -671,6 +734,15 @@ the stack discarding the rest of the stack.</p>
|
|||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.yin_functions">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">yin_functions</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#yin_functions"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.yin_functions" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return a dict of named stack effects.</p>
|
||||
<p>“Yin” functions are those that only rearrange items in stacks and
|
||||
can be defined completely by their stack effects. This means they
|
||||
can be auto-compiled.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.library.zip_">
|
||||
<code class="descclassname">joy.library.</code><code class="descname">zip_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#zip_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.zip_" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
|
|||
|
|
@ -498,8 +498,9 @@ machine transition table.</p>
|
|||
</pre></div>
|
||||
</div>
|
||||
<p>Says, “Three or more 1’s and not ending in 01 nor composed of all 1’s.”</p>
|
||||
<div class="figure">
|
||||
<img alt="State Machine Diagram" src="../_images/omg.svg" /></div>
|
||||
<div class="figure" id="id2">
|
||||
<img alt="omg.svg" src="../_images/omg.svg" /><p class="caption"><span class="caption-text">omg.svg</span></p>
|
||||
</div>
|
||||
<p>Start at <code class="docutils literal notranslate"><span class="pre">a</span></code> and follow the transition arrows according to their
|
||||
labels. Accepting states have a double outline. (Graphic generated with
|
||||
<a class="reference external" href="http://www.graphviz.org/">Dot from Graphviz</a>.) You’ll see that only
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -43,10 +43,14 @@ expression as well as a single Symbol class and a single Exception type.</p>
|
|||
by the fact that they are not Symbol objects.</p>
|
||||
<p>A crude grammar:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span>
|
||||
<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">'['</span> <span class="n">joy</span> <span class="s1">']'</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">'['</span> <span class="n">joy</span> <span class="s1">']'</span> <span class="o">|</span> <span class="n">symbol</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>A Joy expression is a sequence of zero or more terms</p>
|
||||
<p>A Joy expression is a sequence of zero or more terms. A term is a
|
||||
literal value (integer, float, string, or Joy expression) or a function
|
||||
symbol. Function symbols are unquoted strings and cannot contain square
|
||||
brackets. Terms must be separated by blanks, which can be omitted
|
||||
around square brackets.</p>
|
||||
<dl class="exception">
|
||||
<dt id="joy.parser.ParseError">
|
||||
<em class="property">exception </em><code class="descclassname">joy.parser.</code><code class="descname">ParseError</code><a class="reference internal" href="_modules/joy/parser.html#ParseError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.parser.ParseError" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
|
|||
|
|
@ -70,11 +70,6 @@
|
|||
<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>
|
||||
<tr class="cg-1">
|
||||
<td></td>
|
||||
<td>   
|
||||
<a href="types.html#module-joy.utils.polytypes"><code class="xref">joy.utils.polytypes</code></a></td><td>
|
||||
<em></em></td></tr>
|
||||
<tr class="cg-1">
|
||||
<td></td>
|
||||
<td>   
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -168,21 +168,21 @@ won’t work because <code class="docutils literal notranslate"><span class="pre
|
|||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.stack.pick">
|
||||
<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>s</em>, <em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition">¶</a></dt>
|
||||
<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>stack</em>, <em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return the nth item on the stack.</p>
|
||||
<table class="docutils field-list" frame="void" rules="none">
|
||||
<col class="field-name" />
|
||||
<col class="field-body" />
|
||||
<tbody valign="top">
|
||||
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
|
||||
<li><strong>s</strong> (<em>stack</em>) – A stack.</li>
|
||||
<li><strong>stack</strong> (<em>stack</em>) – A stack.</li>
|
||||
<li><strong>n</strong> (<em>int</em>) – An index into the stack.</li>
|
||||
</ul>
|
||||
</td>
|
||||
</tr>
|
||||
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><ul class="first simple">
|
||||
<li><strong>ValueError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is less than zero.</li>
|
||||
<li><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">s</span></code>.</li>
|
||||
<li><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">stack</span></code>.</li>
|
||||
</ul>
|
||||
</td>
|
||||
</tr>
|
||||
|
|
|
|||
|
|
@ -117,6 +117,18 @@
|
|||
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.CombinatorJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.CombinatorJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Represent combinators.</p>
|
||||
<p>These type variables carry Joy functions that implement the
|
||||
behaviour of Joy combinators and they can appear in expressions.
|
||||
For simple combinators the implementation functions can be the
|
||||
combinators themselves.</p>
|
||||
<p>These types can also specify a stack effect (input side only) to
|
||||
guard against being used on invalid types.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.FloatJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FloatJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FloatJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FloatJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -128,6 +140,11 @@
|
|||
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.FunctionJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FunctionJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FunctionJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FunctionJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
<dd></dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.IntJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">IntJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#IntJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.IntJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -144,6 +161,29 @@
|
|||
<em class="property">exception </em><code class="descclassname">joy.utils.types.</code><code class="descname">JoyTypeError</code><a class="reference internal" href="_modules/joy/utils/types.html#JoyTypeError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.JoyTypeError" title="Permalink to this definition">¶</a></dt>
|
||||
<dd></dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.KleeneStar">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">KleeneStar</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#KleeneStar"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.KleeneStar" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>A sequence of zero or more <cite>AnyJoyType</cite> variables would be:</p>
|
||||
<blockquote>
|
||||
<div>A*</div></blockquote>
|
||||
<p>The <cite>A*</cite> works by splitting the universe into two alternate histories:</p>
|
||||
<blockquote>
|
||||
<div><p>A* → ∅</p>
|
||||
<p>A* → A A*</p>
|
||||
</div></blockquote>
|
||||
<p>The Kleene star variable disappears in one universe, and in the other
|
||||
it turns into an <cite>AnyJoyType</cite> variable followed by itself again.</p>
|
||||
<p>We have to return all universes (represented by their substitution
|
||||
dicts, the “unifiers”) that don’t lead to type conflicts.</p>
|
||||
<dl class="attribute">
|
||||
<dt id="joy.utils.types.KleeneStar.kind">
|
||||
<code class="descname">kind</code><a class="headerlink" href="#joy.utils.types.KleeneStar.kind" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>alias of <a class="reference internal" href="#joy.utils.types.AnyJoyType" title="joy.utils.types.AnyJoyType"><code class="xref py py-class docutils literal notranslate"><span class="pre">AnyJoyType</span></code></a></p>
|
||||
</dd></dl>
|
||||
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.NumberJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">NumberJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#NumberJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.NumberJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -160,6 +200,25 @@
|
|||
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.SymbolJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">SymbolJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#SymbolJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.SymbolJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Represent non-combinator functions.</p>
|
||||
<p>These type variables carry the stack effect comments and can
|
||||
appear in expressions (as in quoted programs.)</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.types.TextJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">TextJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#TextJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.TextJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><dl class="attribute">
|
||||
<dt id="joy.utils.types.TextJoyType.accept">
|
||||
<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.TextJoyType.accept" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.basestring</span></code></p>
|
||||
</dd></dl>
|
||||
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.compilable">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">compilable</code><span class="sig-paren">(</span><em>f</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compilable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compilable" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -181,12 +240,6 @@ is used to generate one.</p>
|
|||
<dd><p>Return the stack effect of the composition of some of stack effects.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.defs">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">defs</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#defs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.defs" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return a dict of named stack effects.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.delabel">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">delabel</code><span class="sig-paren">(</span><em>f</em>, <em>seen=None</em>, <em>c=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#delabel"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.delabel" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -195,10 +248,40 @@ is used to generate one.</p>
|
|||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.doc_from_stack_effect">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition">¶</a></dt>
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs=('??'</em>, <em>())</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return a crude string representation of a stack effect.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.infer">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">infer</code><span class="sig-paren">(</span><em>*expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#infer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.infer" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return a list of stack effects for a Joy expression.</p>
|
||||
<p>For example:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">h</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
|
||||
<span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">h</span><span class="p">:</span>
|
||||
<span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Prints:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.meta_compose">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">meta_compose</code><span class="sig-paren">(</span><em>F</em>, <em>G</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#meta_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.meta_compose" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Yield the stack effects of the composition of two lists of stack
|
||||
effects. An expression is carried along and updated and yielded.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.poly_compose">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">poly_compose</code><span class="sig-paren">(</span><em>f</em>, <em>g</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#poly_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.poly_compose" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Yield the stack effects of the composition of two stack effects. An
|
||||
expression is carried along and updated and yielded.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.reify">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">reify</code><span class="sig-paren">(</span><em>meaning</em>, <em>name</em>, <em>seen=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#reify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.reify" title="Permalink to this definition">¶</a></dt>
|
||||
|
|
@ -212,8 +295,16 @@ is used to generate one.</p>
|
|||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.unify">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.unify" title="Permalink to this definition">¶</a></dt>
|
||||
<dt id="joy.utils.types.type_check">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">type_check</code><span class="sig-paren">(</span><em>name</em>, <em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#type_check"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.type_check" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Trinary predicate. True if named function type-checks, False if it
|
||||
fails, None if it’s indeterminate (because I haven’t entered it into
|
||||
the FUNCTIONS dict yet.)</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="function">
|
||||
<dt id="joy.utils.types.uni_unify">
|
||||
<code class="descclassname">joy.utils.types.</code><code class="descname">uni_unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#uni_unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.uni_unify" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Return a substitution dict representing a unifier for u and v.</p>
|
||||
</dd></dl>
|
||||
|
||||
|
|
@ -272,114 +363,6 @@ is used to generate one.</p>
|
|||
(i2 i1 -- i3)
|
||||
</pre></div>
|
||||
</div>
|
||||
<span class="target" id="module-joy.utils.polytypes"></span><p>Multiple Stack Effects</p>
|
||||
<p>By adjusting the machinery in types.py to handles lists of stack effect comments
|
||||
we can capture more information about the type signatures of some functions,
|
||||
and we can introduce a kind of Kleene Star or sequence type that can stand for
|
||||
an unbounded sequence of other types.</p>
|
||||
<dl class="class">
|
||||
<dt id="joy.utils.polytypes.CombinatorJoyType">
|
||||
<em class="property">class </em><code class="descclassname">joy.utils.polytypes.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/polytypes.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.polytypes.CombinatorJoyType" title="Permalink to this definition">¶</a></dt>
|
||||
<dd><p>Represent combinators.</p>
|
||||
<p>These type variables carry Joy functions that implement the
|
||||
behaviour of Joy combinators and they can appear in expressions.
|
||||
For simple combinators the implementation functions can be the
|
||||
combinators themselves.</p>
|
||||
<p>These types can also specify a stack effect (input side only) to
|
||||
guard against being used on invalid types.</p>
|
||||
</dd></dl>
|
||||
|
||||
<dl class="data">
|
||||
<dt id="joy.utils.polytypes.FUNCTIONS">
|
||||
<code class="descclassname">joy.utils.polytypes.</code><code class="descname">FUNCTIONS</code><em class="property"> = {'!=': ne, '&': and, '*': mul, '+': add, '++': succ, '-': sub, '--': pred, '/': truediv, '<': lt, '<<': lshift, '<=': le, '<>': ne, '=': eq, '>': gt, '>=': ge, '>>': 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<': rolldown, 'roll>': 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>
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue