Rebuilt some docs. Minor edits.

2020-04-24 16:10:28 -07:00
parent 1863cba7f7
commit 14f706cd96
22 changed files with 1949 additions and 2542 deletions
@@ -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">&#39;&#39;&#39;</span>
 <span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
-<span class="k">try</span><span class="p">:</span>
-  <span class="nb">input</span> <span class="o">=</span> <span class="n">raw_input</span>
-<span class="k">except</span> <span class="ne">NameError</span><span class="p">:</span>
-  <span class="k">pass</span>
+<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">input</span>
 <span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span><span class="p">,</span> <span class="n">format_exc</span>
 <span class="kn">from</span> <span class="nn">.parser</span> <span class="k">import</span> <span class="n">text_to_expression</span><span class="p">,</span> <span class="n">ParseError</span><span class="p">,</span> <span class="n">Symbol</span>
 <span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">stack_to_string</span>
@@ -68,86 +65,89 @@


 <div class="viewcode-block" id="joy"><a class="viewcode-back" href="../../joy.html#joy.joy.joy">[docs]</a><span class="k">def</span> <span class="nf">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Evaluate the Joy expression on the stack.</span>
-<span class="sd">  </span>
-<span class="sd">  The basic joy() function is quite straightforward.  It iterates through a</span>
-<span class="sd">  sequence of terms which are either literals (strings, numbers, sequences)</span>
-<span class="sd">  or functions.  Literals are put onto the stack and functions are</span>
-<span class="sd">  executed.</span>
+	<span class="sd">&#39;&#39;&#39;Evaluate a Joy expression on a stack.</span>

-<span class="sd">  :param stack stack: The stack.</span>
-<span class="sd">  :param stack expression: The expression to evaluate.</span>
-<span class="sd">  :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
-<span class="sd">  :param function viewer: Optional viewer function.</span>
-<span class="sd">  :rtype: (stack, (), dictionary)</span>
+<span class="sd">	This function iterates through a sequence of terms which are either</span>
+<span class="sd">	literals (strings, numbers, sequences of terms) or function symbols.</span>
+<span class="sd">	Literals are put onto the stack and functions are looked up in the</span>
+<span class="sd">	disctionary and executed.</span>

-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">while</span> <span class="n">expression</span><span class="p">:</span>
+<span class="sd">	The viewer is a function that is called with the stack and expression</span>
+<span class="sd">	on every iteration, its return value is ignored.</span>

-    <span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
+<span class="sd">	:param stack stack: The stack.</span>
+<span class="sd">	:param stack expression: The expression to evaluate.</span>
+<span class="sd">	:param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
+<span class="sd">	:param function viewer: Optional viewer function.</span>
+<span class="sd">	:rtype: (stack, (), dictionary)</span>

-    <span class="n">term</span><span class="p">,</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">expression</span>
-    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">term</span><span class="p">,</span> <span class="n">Symbol</span><span class="p">):</span>
-      <span class="n">term</span> <span class="o">=</span> <span class="n">dictionary</span><span class="p">[</span><span class="n">term</span><span class="p">]</span>
-      <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="n">term</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span>
-    <span class="k">else</span><span class="p">:</span>
-      <span class="n">stack</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">stack</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">while</span> <span class="n">expression</span><span class="p">:</span>

-  <span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
-  <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
+		<span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
+
+		<span class="n">term</span><span class="p">,</span> <span class="n">expression</span> <span class="o">=</span> <span class="n">expression</span>
+		<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">term</span><span class="p">,</span> <span class="n">Symbol</span><span class="p">):</span>
+			<span class="n">term</span> <span class="o">=</span> <span class="n">dictionary</span><span class="p">[</span><span class="n">term</span><span class="p">]</span>
+			<span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="n">term</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">)</span>
+		<span class="k">else</span><span class="p">:</span>
+			<span class="n">stack</span> <span class="o">=</span> <span class="n">term</span><span class="p">,</span> <span class="n">stack</span>
+
+	<span class="k">if</span> <span class="n">viewer</span><span class="p">:</span> <span class="n">viewer</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
+	<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>


 <div class="viewcode-block" id="run"><a class="viewcode-back" href="../../joy.html#joy.joy.run">[docs]</a><span class="k">def</span> <span class="nf">run</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Return the stack resulting from running the Joy code text on the stack.</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Return the stack resulting from running the Joy code text on the stack.</span>

-<span class="sd">  :param str text: Joy code.</span>
-<span class="sd">  :param stack stack: The stack.</span>
-<span class="sd">  :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
-<span class="sd">  :param function viewer: Optional viewer function.</span>
-<span class="sd">  :rtype: (stack, (), dictionary)</span>
+<span class="sd">	:param str text: Joy code.</span>
+<span class="sd">	:param stack stack: The stack.</span>
+<span class="sd">	:param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
+<span class="sd">	:param function viewer: Optional viewer function.</span>
+<span class="sd">	:rtype: (stack, (), dictionary)</span>

-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="n">expression</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
-  <span class="k">return</span> <span class="n">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="p">)</span></div>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="n">expression</span> <span class="o">=</span> <span class="n">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
+	<span class="k">return</span> <span class="n">joy</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="p">)</span></div>


 <div class="viewcode-block" id="repl"><a class="viewcode-back" href="../../joy.html#joy.joy.repl">[docs]</a><span class="k">def</span> <span class="nf">repl</span><span class="p">(</span><span class="n">stack</span><span class="o">=</span><span class="p">(),</span> <span class="n">dictionary</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Read-Evaluate-Print Loop</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Read-Evaluate-Print Loop</span>

-<span class="sd">  Accept input and run it on the stack, loop.</span>
+<span class="sd">	Accept input and run it on the stack, loop.</span>

-<span class="sd">  :param stack stack: The stack.</span>
-<span class="sd">  :param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
-<span class="sd">  :rtype: stack</span>
+<span class="sd">	:param stack stack: The stack.</span>
+<span class="sd">	:param dict dictionary: A ``dict`` mapping names to Joy functions.</span>
+<span class="sd">	:rtype: stack</span>

-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">if</span> <span class="n">dictionary</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
-    <span class="n">dictionary</span> <span class="o">=</span> <span class="p">{}</span>
-  <span class="k">try</span><span class="p">:</span>
-    <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
-      <span class="nb">print</span><span class="p">()</span>
-      <span class="nb">print</span><span class="p">(</span><span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">),</span> <span class="s1">&#39;&lt;-top&#39;</span><span class="p">)</span>
-      <span class="nb">print</span><span class="p">()</span>
-      <span class="k">try</span><span class="p">:</span>
-        <span class="n">text</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">&#39;joy? &#39;</span><span class="p">)</span>
-      <span class="k">except</span> <span class="p">(</span><span class="ne">EOFError</span><span class="p">,</span> <span class="ne">KeyboardInterrupt</span><span class="p">):</span>
-        <span class="k">break</span>
-      <span class="n">viewer</span> <span class="o">=</span> <span class="n">TracePrinter</span><span class="p">()</span>
-      <span class="k">try</span><span class="p">:</span>
-        <span class="n">stack</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="n">run</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">.</span><span class="n">viewer</span><span class="p">)</span>
-      <span class="k">except</span><span class="p">:</span>
-        <span class="n">exc</span> <span class="o">=</span> <span class="n">format_exc</span><span class="p">()</span> <span class="c1"># Capture the exception.</span>
-        <span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="c1"># Print the Joy trace.</span>
-        <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;-&#39;</span> <span class="o">*</span> <span class="mi">73</span><span class="p">)</span>
-        <span class="nb">print</span><span class="p">(</span><span class="n">exc</span><span class="p">)</span> <span class="c1"># Print the original exception.</span>
-      <span class="k">else</span><span class="p">:</span>
-        <span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
-  <span class="k">except</span><span class="p">:</span>
-    <span class="n">print_exc</span><span class="p">()</span>
-  <span class="nb">print</span><span class="p">()</span>
-  <span class="k">return</span> <span class="n">stack</span></div>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">if</span> <span class="n">dictionary</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+		<span class="n">dictionary</span> <span class="o">=</span> <span class="p">{}</span>
+	<span class="k">try</span><span class="p">:</span>
+		<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
+			<span class="nb">print</span><span class="p">()</span>
+			<span class="nb">print</span><span class="p">(</span><span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">),</span> <span class="s1">&#39;&lt;-top&#39;</span><span class="p">)</span>
+			<span class="nb">print</span><span class="p">()</span>
+			<span class="k">try</span><span class="p">:</span>
+				<span class="n">text</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span class="s1">&#39;joy? &#39;</span><span class="p">)</span>
+			<span class="k">except</span> <span class="p">(</span><span class="ne">EOFError</span><span class="p">,</span> <span class="ne">KeyboardInterrupt</span><span class="p">):</span>
+				<span class="k">break</span>
+			<span class="n">viewer</span> <span class="o">=</span> <span class="n">TracePrinter</span><span class="p">()</span>
+			<span class="k">try</span><span class="p">:</span>
+				<span class="n">stack</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">dictionary</span> <span class="o">=</span> <span class="n">run</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">,</span> <span class="n">viewer</span><span class="o">.</span><span class="n">viewer</span><span class="p">)</span>
+			<span class="k">except</span><span class="p">:</span>
+				<span class="n">exc</span> <span class="o">=</span> <span class="n">format_exc</span><span class="p">()</span> <span class="c1"># Capture the exception.</span>
+				<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span> <span class="c1"># Print the Joy trace.</span>
+				<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;-&#39;</span> <span class="o">*</span> <span class="mi">73</span><span class="p">)</span>
+				<span class="nb">print</span><span class="p">(</span><span class="n">exc</span><span class="p">)</span> <span class="c1"># Print the original exception.</span>
+			<span class="k">else</span><span class="p">:</span>
+				<span class="n">viewer</span><span class="o">.</span><span class="n">print_</span><span class="p">()</span>
+	<span class="k">except</span><span class="p">:</span>
+		<span class="n">print_exc</span><span class="p">()</span>
+	<span class="nb">print</span><span class="p">()</span>
+	<span class="k">return</span> <span class="n">stack</span></div>
 </pre></div>

          </div>
@@ -59,90 +59,102 @@

 <span class="sd">A crude grammar::</span>

-<span class="sd">  joy = term*</span>
-<span class="sd">  term = int | float | string | &#39;[&#39; joy &#39;]&#39; | function</span>
-
-<span class="sd">A Joy expression is a sequence of zero or more terms</span>
+<span class="sd">    joy = term*</span>
+<span class="sd">    term = int | float | string | &#39;[&#39; joy &#39;]&#39; | symbol</span>

+<span class="sd">A Joy expression is a sequence of zero or more terms.  A term is a</span>
+<span class="sd">literal value (integer, float, string, or Joy expression) or a function</span>
+<span class="sd">symbol.  Function symbols are unquoted strings and cannot contain square</span>
+<span class="sd">brackets.   Terms must be separated by blanks, which can be omitted</span>
+<span class="sd">around square brackets.</span>

 <span class="sd">&#39;&#39;&#39;</span>
-<span class="c1">#TODO: explain the details of float lits and strings.</span>
 <span class="kn">from</span> <span class="nn">re</span> <span class="k">import</span> <span class="n">Scanner</span>
 <span class="kn">from</span> <span class="nn">.utils.stack</span> <span class="k">import</span> <span class="n">list_to_stack</span>


+<span class="c1">#TODO: explain the details of float lits and strings.</span>
+<span class="n">FLOAT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*&#39;</span>
+<span class="n">INT</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;-?\d+&#39;</span>
+<span class="n">SYMBOL</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;[•\w!@$%^&amp;*()_+&lt;&gt;?|\/;:`~,.=-]+&#39;</span>
+<span class="n">BRACKETS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</span>
+<span class="n">STRING_DOUBLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;&quot;(?:[^&quot;</span><span class="se">\\</span><span class="s1">]|</span><span class="se">\\</span><span class="s1">.)*&quot;&#39;</span>
+<span class="n">STRING_SINGLE_QUOTED</span> <span class="o">=</span> <span class="sa">r</span><span class="s2">&quot;&#39;(?:[^&#39;</span><span class="se">\\</span><span class="s2">]|</span><span class="se">\\</span><span class="s2">.)*&#39;&quot;</span>
+<span class="n">BLANKS</span> <span class="o">=</span> <span class="sa">r</span><span class="s1">&#39;\s+&#39;</span>
+
+
 <div class="viewcode-block" id="Symbol"><a class="viewcode-back" href="../../parser.html#joy.parser.Symbol">[docs]</a><span class="k">class</span> <span class="nc">Symbol</span><span class="p">(</span><span class="nb">str</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span>
-  <span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div>
+	<span class="sd">&#39;&#39;&#39;A string class that represents Joy function names.&#39;&#39;&#39;</span>
+	<span class="fm">__repr__</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="fm">__str__</span></div>


 <div class="viewcode-block" id="text_to_expression"><a class="viewcode-back" href="../../parser.html#joy.parser.text_to_expression">[docs]</a><span class="k">def</span> <span class="nf">text_to_expression</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Convert a string to a Joy expression.</span>
+	<span class="sd">&#39;&#39;&#39;Convert a string to a Joy expression.</span>

-<span class="sd">  When supplied with a string this function returns a Python datastructure</span>
-<span class="sd">  that represents the Joy datastructure described by the text expression.</span>
-<span class="sd">  Any unbalanced square brackets will raise a ParseError.</span>
+<span class="sd">	When supplied with a string this function returns a Python datastructure</span>
+<span class="sd">	that represents the Joy datastructure described by the text expression.</span>
+<span class="sd">	Any unbalanced square brackets will raise a ParseError.</span>

-<span class="sd">  :param str text: Text to convert.</span>
-<span class="sd">  :rtype: stack</span>
-<span class="sd">  :raises ParseError: if the parse fails.</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">return</span> <span class="n">_parse</span><span class="p">(</span><span class="n">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">))</span></div>
+<span class="sd">	:param str text: Text to convert.</span>
+<span class="sd">	:rtype: stack</span>
+<span class="sd">	:raises ParseError: if the parse fails.</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">return</span> <span class="n">_parse</span><span class="p">(</span><span class="n">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">))</span></div>


 <div class="viewcode-block" id="ParseError"><a class="viewcode-back" href="../../parser.html#joy.parser.ParseError">[docs]</a><span class="k">class</span> <span class="nc">ParseError</span><span class="p">(</span><span class="ne">ValueError</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Raised when there is a error while parsing text.&#39;&#39;&#39;</span></div>
+	<span class="sd">&#39;&#39;&#39;Raised when there is a error while parsing text.&#39;&#39;&#39;</span></div>


 <span class="k">def</span> <span class="nf">_tokenize</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Convert a text into a stream of tokens.</span>
+	<span class="sd">&#39;&#39;&#39;Convert a text into a stream of tokens.</span>

-<span class="sd">  Converts function names to Symbols.</span>
+<span class="sd">	Converts function names to Symbols.</span>

-<span class="sd">  Raise ParseError (with some of the failing text) if the scan fails.</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="n">tokens</span><span class="p">,</span> <span class="n">rest</span> <span class="o">=</span> <span class="n">_scanner</span><span class="o">.</span><span class="n">scan</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
-  <span class="k">if</span> <span class="n">rest</span><span class="p">:</span>
-    <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span>
-      <span class="s1">&#39;Scan failed at position </span><span class="si">%i</span><span class="s1">, </span><span class="si">%r</span><span class="s1">&#39;</span>
-      <span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="o">-</span> <span class="nb">len</span><span class="p">(</span><span class="n">rest</span><span class="p">),</span> <span class="n">rest</span><span class="p">[:</span><span class="mi">10</span><span class="p">])</span>
-      <span class="p">)</span>
-  <span class="k">return</span> <span class="n">tokens</span>
+<span class="sd">	Raise ParseError (with some of the failing text) if the scan fails.</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="n">tokens</span><span class="p">,</span> <span class="n">rest</span> <span class="o">=</span> <span class="n">_scanner</span><span class="o">.</span><span class="n">scan</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
+	<span class="k">if</span> <span class="n">rest</span><span class="p">:</span>
+		<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span>
+			<span class="s1">&#39;Scan failed at position </span><span class="si">%i</span><span class="s1">, </span><span class="si">%r</span><span class="s1">&#39;</span>
+			<span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="o">-</span> <span class="nb">len</span><span class="p">(</span><span class="n">rest</span><span class="p">),</span> <span class="n">rest</span><span class="p">[:</span><span class="mi">10</span><span class="p">])</span>
+			<span class="p">)</span>
+	<span class="k">return</span> <span class="n">tokens</span>


 <span class="k">def</span> <span class="nf">_parse</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Return a stack/list expression of the tokens.</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
-  <span class="n">stack</span> <span class="o">=</span> <span class="p">[]</span>
-  <span class="k">for</span> <span class="n">tok</span> <span class="ow">in</span> <span class="n">tokens</span><span class="p">:</span>
-    <span class="k">if</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;[&#39;</span><span class="p">:</span>
-      <span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
-      <span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
-      <span class="n">stack</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
-    <span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;]&#39;</span><span class="p">:</span>
-      <span class="k">try</span><span class="p">:</span>
-        <span class="n">frame</span> <span class="o">=</span> <span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
-      <span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
-        <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Extra closing bracket.&#39;</span><span class="p">)</span>
-      <span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
-    <span class="k">else</span><span class="p">:</span>
-      <span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">tok</span><span class="p">)</span>
-  <span class="k">if</span> <span class="n">stack</span><span class="p">:</span>
-    <span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Unclosed bracket.&#39;</span><span class="p">)</span>
-  <span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Return a stack/list expression of the tokens.</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
+	<span class="n">stack</span> <span class="o">=</span> <span class="p">[]</span>
+	<span class="k">for</span> <span class="n">tok</span> <span class="ow">in</span> <span class="n">tokens</span><span class="p">:</span>
+		<span class="k">if</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;[&#39;</span><span class="p">:</span>
+			<span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
+			<span class="n">frame</span> <span class="o">=</span> <span class="p">[]</span>
+			<span class="n">stack</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>
+		<span class="k">elif</span> <span class="n">tok</span> <span class="o">==</span> <span class="s1">&#39;]&#39;</span><span class="p">:</span>
+			<span class="k">try</span><span class="p">:</span>
+				<span class="n">frame</span> <span class="o">=</span> <span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
+			<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
+				<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Extra closing bracket.&#39;</span><span class="p">)</span>
+			<span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
+		<span class="k">else</span><span class="p">:</span>
+			<span class="n">frame</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">tok</span><span class="p">)</span>
+	<span class="k">if</span> <span class="n">stack</span><span class="p">:</span>
+		<span class="k">raise</span> <span class="n">ParseError</span><span class="p">(</span><span class="s1">&#39;Unclosed bracket.&#39;</span><span class="p">)</span>
+	<span class="k">return</span> <span class="n">list_to_stack</span><span class="p">(</span><span class="n">frame</span><span class="p">)</span>


 <span class="n">_scanner</span> <span class="o">=</span> <span class="n">Scanner</span><span class="p">([</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;-?\d+\.\d*&#39;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;-?\d+&#39;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;[•\w!@$%^&amp;*()_+&lt;&gt;?|\/;:`~,.=-]+&#39;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">Symbol</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;\[|\]&#39;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;&quot;(?:[^&quot;</span><span class="se">\\</span><span class="s1">]|</span><span class="se">\\</span><span class="s1">.)*&quot;&#39;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\\</span><span class="s1">&quot;&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">)),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s2">&quot;&#39;(?:[^&#39;</span><span class="se">\\</span><span class="s2">]|</span><span class="se">\\</span><span class="s2">.)*&#39;&quot;</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\\</span><span class="s2">&#39;&quot;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">)),</span>
-  <span class="p">(</span><span class="sa">r</span><span class="s1">&#39;\s+&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
-  <span class="p">])</span>
+	<span class="p">(</span><span class="n">FLOAT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
+	<span class="p">(</span><span class="n">INT</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
+	<span class="p">(</span><span class="n">SYMBOL</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">Symbol</span><span class="p">(</span><span class="n">token</span><span class="p">)),</span>
+	<span class="p">(</span><span class="n">BRACKETS</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">),</span>
+	<span class="p">(</span><span class="n">STRING_DOUBLE_QUOTED</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\\</span><span class="s1">&quot;&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">)),</span>
+	<span class="p">(</span><span class="n">STRING_SINGLE_QUOTED</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">_</span><span class="p">,</span> <span class="n">token</span><span class="p">:</span> <span class="n">token</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\\</span><span class="s2">&#39;&quot;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">)),</span>
+	<span class="p">(</span><span class="n">BLANKS</span><span class="p">,</span> <span class="kc">None</span><span class="p">),</span>
+	<span class="p">])</span>
 </pre></div>

          </div>
@@ -73,62 +73,63 @@
 <span class="c1"># (Kinda clunky and hacky.  This should be swapped out in favor of much</span>
 <span class="c1"># smarter stuff.)</span>
 <span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">print_function</span>
+<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">object</span>
 <span class="kn">from</span> <span class="nn">traceback</span> <span class="k">import</span> <span class="n">print_exc</span>
 <span class="kn">from</span> <span class="nn">.stack</span> <span class="k">import</span> <span class="n">expression_to_string</span><span class="p">,</span> <span class="n">stack_to_string</span>


 <div class="viewcode-block" id="TracePrinter"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter">[docs]</a><span class="k">class</span> <span class="nc">TracePrinter</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  This is what does the formatting.  You instantiate it and pass the ``viewer()``</span>
-<span class="sd">  method to the :py:func:`joy.joy.joy` function, then print it to see the</span>
-<span class="sd">  trace.</span>
-<span class="sd">  &#39;&#39;&#39;</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	This is what does the formatting.  You instantiate it and pass the ``viewer()``</span>
+<span class="sd">	method to the :py:func:`joy.joy.joy` function, then print it to see the</span>
+<span class="sd">	trace.</span>
+<span class="sd">	&#39;&#39;&#39;</span>

-  <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-    <span class="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="p">[]</span>
+	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+		<span class="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="p">[]</span>

-<div class="viewcode-block" id="TracePrinter.viewer"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.viewer">[docs]</a>  <span class="k">def</span> <span class="nf">viewer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
-    <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">    Record the current stack and expression in the TracePrinter&#39;s history.</span>
-<span class="sd">    Pass this method as the ``viewer`` argument to the :py:func:`joy.joy.joy` function.</span>
+<div class="viewcode-block" id="TracePrinter.viewer"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.viewer">[docs]</a>	<span class="k">def</span> <span class="nf">viewer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
+		<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">		Record the current stack and expression in the TracePrinter&#39;s history.</span>
+<span class="sd">		Pass this method as the ``viewer`` argument to the :py:func:`joy.joy.joy` function.</span>

-<span class="sd">    :param stack quote: A stack.</span>
-<span class="sd">    :param stack expression: A stack.</span>
-<span class="sd">    &#39;&#39;&#39;</span>
-    <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span></div>
+<span class="sd">		:param stack quote: A stack.</span>
+<span class="sd">		:param stack expression: A stack.</span>
+<span class="sd">		&#39;&#39;&#39;</span>
+		<span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">))</span></div>

-  <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-    <span class="k">return</span> <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">go</span><span class="p">())</span>
+	<span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+		<span class="k">return</span> <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">go</span><span class="p">())</span>

-<div class="viewcode-block" id="TracePrinter.go"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.go">[docs]</a>  <span class="k">def</span> <span class="nf">go</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-    <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">    Return a list of strings, one for each entry in the history, prefixed</span>
-<span class="sd">    with enough spaces to align all the interpreter dots.</span>
+<div class="viewcode-block" id="TracePrinter.go"><a class="viewcode-back" href="../../../pretty.html#joy.utils.pretty_print.TracePrinter.go">[docs]</a>	<span class="k">def</span> <span class="nf">go</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+		<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">		Return a list of strings, one for each entry in the history, prefixed</span>
+<span class="sd">		with enough spaces to align all the interpreter dots.</span>

-<span class="sd">    This method is called internally by the ``__str__()`` method.</span>
+<span class="sd">		This method is called internally by the ``__str__()`` method.</span>

-<span class="sd">    :rtype: list(str)</span>
-<span class="sd">    &#39;&#39;&#39;</span>
-    <span class="n">max_stack_length</span> <span class="o">=</span> <span class="mi">0</span>
-    <span class="n">lines</span> <span class="o">=</span> <span class="p">[]</span>
-    <span class="k">for</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">:</span>
-      <span class="n">stack</span> <span class="o">=</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
-      <span class="n">expression</span> <span class="o">=</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">)</span>
-      <span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
-      <span class="k">if</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="n">max_stack_length</span><span class="p">:</span>
-        <span class="n">max_stack_length</span> <span class="o">=</span> <span class="n">n</span>
-      <span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> . </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
-    <span class="k">return</span> <span class="p">[</span>  <span class="c1"># Prefix spaces to line up &#39;.&#39;s.</span>
-      <span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="o">*</span> <span class="p">(</span><span class="n">max_stack_length</span> <span class="o">-</span> <span class="n">length</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">)</span>
-      <span class="k">for</span> <span class="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span>
-      <span class="p">]</span></div>
+<span class="sd">		:rtype: list(str)</span>
+<span class="sd">		&#39;&#39;&#39;</span>
+		<span class="n">max_stack_length</span> <span class="o">=</span> <span class="mi">0</span>
+		<span class="n">lines</span> <span class="o">=</span> <span class="p">[]</span>
+		<span class="k">for</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">:</span>
+			<span class="n">stack</span> <span class="o">=</span> <span class="n">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
+			<span class="n">expression</span> <span class="o">=</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">)</span>
+			<span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
+			<span class="k">if</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="n">max_stack_length</span><span class="p">:</span>
+				<span class="n">max_stack_length</span> <span class="o">=</span> <span class="n">n</span>
+			<span class="n">lines</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">n</span><span class="p">,</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> . </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">)))</span>
+		<span class="k">return</span> <span class="p">[</span>  <span class="c1"># Prefix spaces to line up &#39;.&#39;s.</span>
+			<span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="o">*</span> <span class="p">(</span><span class="n">max_stack_length</span> <span class="o">-</span> <span class="n">length</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">)</span>
+			<span class="k">for</span> <span class="n">length</span><span class="p">,</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span>
+			<span class="p">]</span></div>

-  <span class="k">def</span> <span class="nf">print_</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-    <span class="k">try</span><span class="p">:</span>
-      <span class="nb">print</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
-    <span class="k">except</span><span class="p">:</span>
-      <span class="n">print_exc</span><span class="p">()</span>
-      <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Exception while printing viewer.&#39;</span><span class="p">)</span></div>
+	<span class="k">def</span> <span class="nf">print_</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+		<span class="k">try</span><span class="p">:</span>
+			<span class="nb">print</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
+		<span class="k">except</span><span class="p">:</span>
+			<span class="n">print_exc</span><span class="p">()</span>
+			<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Exception while printing viewer.&#39;</span><span class="p">)</span></div>
 </pre></div>

          </div>
@@ -76,8 +76,8 @@

 <span class="sd">For example::</span>

-<span class="sd">  def dup((head, tail)):</span>
-<span class="sd">    return head, (head, tail)</span>
+<span class="sd">	def dup((head, tail)):</span>
+<span class="sd">		return head, (head, tail)</span>

 <span class="sd">We replace the argument &quot;stack&quot; by the expected structure of the stack,</span>
 <span class="sd">in this case &quot;(head, tail)&quot;, and Python takes care of unpacking the</span>
@@ -89,9 +89,9 @@
 <span class="sd">web page, doesn&#39;t handle tuples in the function parameters.  And in Python 3, this</span>
 <span class="sd">syntax was removed entirely.  Instead you would have to write::</span>

-<span class="sd">  def dup(stack):</span>
-<span class="sd">    head, tail = stack</span>
-<span class="sd">    return head, (head, tail)</span>
+<span class="sd">	def dup(stack):</span>
+<span class="sd">		head, tail = stack</span>
+<span class="sd">		return head, (head, tail)</span>


 <span class="sd">We have two very simple functions, one to build up a stack from a Python</span>
@@ -105,98 +105,97 @@
 <span class="sd">&#39;&#39;&#39;</span>


+<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">map</span>
 <div class="viewcode-block" id="list_to_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.list_to_stack">[docs]</a><span class="k">def</span> <span class="nf">list_to_stack</span><span class="p">(</span><span class="n">el</span><span class="p">,</span> <span class="n">stack</span><span class="o">=</span><span class="p">()):</span>
-  <span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span>
+	<span class="sd">&#39;&#39;&#39;Convert a Python list (or other sequence) to a Joy stack::</span>

-<span class="sd">  [1, 2, 3] -&gt; (1, (2, (3, ())))</span>
+<span class="sd">	[1, 2, 3] -&gt; (1, (2, (3, ())))</span>

-<span class="sd">  :param list el: A Python list or other sequence (iterators and generators</span>
-<span class="sd">       won&#39;t work because ``reverse()`` is called on ``el``.)</span>
-<span class="sd">  :param stack stack: A stack, optional, defaults to the empty stack.</span>
-<span class="sd">  :rtype: stack</span>
+<span class="sd">	:param list el: A Python list or other sequence (iterators and generators</span>
+<span class="sd">			 won&#39;t work because ``reverse()`` is called on ``el``.)</span>
+<span class="sd">	:param stack stack: A stack, optional, defaults to the empty stack.</span>
+<span class="sd">	:rtype: stack</span>

-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="n">el</span><span class="p">):</span>
-    <span class="n">stack</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span>
-  <span class="k">return</span> <span class="n">stack</span></div>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="n">el</span><span class="p">):</span>
+		<span class="n">stack</span> <span class="o">=</span> <span class="n">item</span><span class="p">,</span> <span class="n">stack</span>
+	<span class="k">return</span> <span class="n">stack</span></div>


 <div class="viewcode-block" id="iter_stack"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.iter_stack">[docs]</a><span class="k">def</span> <span class="nf">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Iterate through the items on the stack.</span>
+	<span class="sd">&#39;&#39;&#39;Iterate through the items on the stack.</span>

-<span class="sd">  :param stack stack: A stack.</span>
-<span class="sd">  :rtype: iterator</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">while</span> <span class="n">stack</span><span class="p">:</span>
-    <span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
-    <span class="k">yield</span> <span class="n">item</span></div>
+<span class="sd">	:param stack stack: A stack.</span>
+<span class="sd">	:rtype: iterator</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">while</span> <span class="n">stack</span><span class="p">:</span>
+		<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
+		<span class="k">yield</span> <span class="n">item</span></div>


 <div class="viewcode-block" id="stack_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.stack_to_string">[docs]</a><span class="k">def</span> <span class="nf">stack_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Return a &quot;pretty print&quot; string for a stack.</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Return a &quot;pretty print&quot; string for a stack.</span>

-<span class="sd">  The items are written right-to-left::</span>
+<span class="sd">	The items are written right-to-left::</span>

-<span class="sd">    (top, (second, ...)) -&gt; &#39;... second top&#39;</span>
+<span class="sd">		(top, (second, ...)) -&gt; &#39;... second top&#39;</span>

-<span class="sd">  :param stack stack: A stack.</span>
-<span class="sd">  :rtype: str</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">stack</span><span class="p">:</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
-  <span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span></div>
+<span class="sd">	:param stack stack: A stack.</span>
+<span class="sd">	:rtype: str</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">stack</span><span class="p">:</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iter_stack</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
+	<span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span></div>


 <div class="viewcode-block" id="expression_to_string"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.expression_to_string">[docs]</a><span class="k">def</span> <span class="nf">expression_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Return a &quot;pretty print&quot; string for a expression.</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Return a &quot;pretty print&quot; string for a expression.</span>

-<span class="sd">  The items are written left-to-right::</span>
+<span class="sd">	The items are written left-to-right::</span>

-<span class="sd">    (top, (second, ...)) -&gt; &#39;top second ...&#39;</span>
+<span class="sd">		(top, (second, ...)) -&gt; &#39;top second ...&#39;</span>

-<span class="sd">  :param stack expression: A stack.</span>
-<span class="sd">  :rtype: str</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">)</span></div>
+<span class="sd">	:param stack expression: A stack.</span>
+<span class="sd">	:rtype: str</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">return</span> <span class="n">_to_string</span><span class="p">(</span><span class="n">expression</span><span class="p">,</span> <span class="n">iter_stack</span><span class="p">)</span></div>


 <span class="k">def</span> <span class="nf">_to_string</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">f</span><span class="p">):</span>
-  <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">long</span><span class="p">):</span> <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s1">&#39;L&#39;</span><span class="p">)</span>
-  <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
-  <span class="k">if</span> <span class="ow">not</span> <span class="n">stack</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;&#39;</span>  <span class="c1"># shortcut</span>
-  <span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>
+	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="n">stack</span><span class="p">)</span>
+	<span class="k">if</span> <span class="ow">not</span> <span class="n">stack</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;&#39;</span>  <span class="c1"># shortcut</span>
+	<span class="k">return</span> <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_s</span><span class="p">,</span> <span class="n">f</span><span class="p">(</span><span class="n">stack</span><span class="p">)))</span>


 <span class="n">_s</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="p">(</span>
-  <span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span>
-  <span class="k">else</span> <span class="nb">str</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s1">&#39;L&#39;</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">long</span><span class="p">)</span>
-  <span class="k">else</span> <span class="nb">repr</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
-  <span class="p">)</span>
+	<span class="s1">&#39;[</span><span class="si">%s</span><span class="s1">]&#39;</span> <span class="o">%</span> <span class="n">expression_to_string</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span>
+	<span class="k">else</span> <span class="nb">repr</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
+	<span class="p">)</span>


 <div class="viewcode-block" id="concat"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.concat">[docs]</a><span class="k">def</span> <span class="nf">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;Concatinate quote onto expression.</span>
+	<span class="sd">&#39;&#39;&#39;Concatinate quote onto expression.</span>

-<span class="sd">  In joy [1 2] [3 4] would become [1 2 3 4].</span>
+<span class="sd">	In joy [1 2] [3 4] would become [1 2 3 4].</span>

-<span class="sd">  :param stack quote: A stack.</span>
-<span class="sd">  :param stack expression: A stack.</span>
-<span class="sd">  :raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
-<span class="sd">  :rtype: stack</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="c1"># This is the fastest implementation, but will trigger</span>
-  <span class="c1"># RuntimeError: maximum recursion depth exceeded</span>
-  <span class="c1"># on quotes longer than sys.getrecursionlimit().</span>
+<span class="sd">	:param stack quote: A stack.</span>
+<span class="sd">	:param stack expression: A stack.</span>
+<span class="sd">	:raises RuntimeError: if quote is larger than sys.getrecursionlimit().</span>
+<span class="sd">	:rtype: stack</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="c1"># This is the fastest implementation, but will trigger</span>
+	<span class="c1"># RuntimeError: maximum recursion depth exceeded</span>
+	<span class="c1"># on quotes longer than sys.getrecursionlimit().</span>

-  <span class="k">return</span> <span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">expression</span><span class="p">))</span> <span class="k">if</span> <span class="n">quote</span> <span class="k">else</span> <span class="n">expression</span></div>
+	<span class="k">return</span> <span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">expression</span><span class="p">))</span> <span class="k">if</span> <span class="n">quote</span> <span class="k">else</span> <span class="n">expression</span></div>

-  <span class="c1"># Original implementation.</span>
+	<span class="c1"># Original implementation.</span>

 <span class="c1">##  return list_to_stack(list(iter_stack(quote)), expression)</span>

-  <span class="c1"># In-lining is slightly faster (and won&#39;t break the</span>
-  <span class="c1"># recursion limit on long quotes.)</span>
+	<span class="c1"># In-lining is slightly faster (and won&#39;t break the</span>
+	<span class="c1"># recursion limit on long quotes.)</span>

 <span class="c1">##  temp = []</span>
 <span class="c1">##  while quote:</span>
@@ -208,27 +207,27 @@



-<div class="viewcode-block" id="pick"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.pick">[docs]</a><span class="k">def</span> <span class="nf">pick</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
-  <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  Return the nth item on the stack.</span>
+<div class="viewcode-block" id="pick"><a class="viewcode-back" href="../../../stack.html#joy.utils.stack.pick">[docs]</a><span class="k">def</span> <span class="nf">pick</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
+	<span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">	Return the nth item on the stack.</span>

-<span class="sd">  :param stack s: A stack.</span>
-<span class="sd">  :param int n: An index into the stack.</span>
-<span class="sd">  :raises ValueError: if ``n`` is less than zero.</span>
-<span class="sd">  :raises IndexError: if ``n`` is equal to or greater than the length of ``s``.</span>
-<span class="sd">  :rtype: whatever</span>
-<span class="sd">  &#39;&#39;&#39;</span>
-  <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
-    <span class="k">raise</span> <span class="ne">ValueError</span>
-  <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
-    <span class="k">try</span><span class="p">:</span>
-      <span class="n">item</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">s</span>
-    <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
-      <span class="k">raise</span> <span class="ne">IndexError</span>
-    <span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
-      <span class="k">break</span>
-  <span class="k">return</span> <span class="n">item</span></div>
+<span class="sd">	:param stack stack: A stack.</span>
+<span class="sd">	:param int n: An index into the stack.</span>
+<span class="sd">	:raises ValueError: if ``n`` is less than zero.</span>
+<span class="sd">	:raises IndexError: if ``n`` is equal to or greater than the length of ``stack``.</span>
+<span class="sd">	:rtype: whatever</span>
+<span class="sd">	&#39;&#39;&#39;</span>
+	<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
+		<span class="k">raise</span> <span class="ne">ValueError</span>
+	<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
+		<span class="k">try</span><span class="p">:</span>
+			<span class="n">item</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
+		<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+			<span class="k">raise</span> <span class="ne">IndexError</span>
+		<span class="n">n</span> <span class="o">-=</span> <span class="mi">1</span>
+		<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
+			<span class="k">break</span>
+	<span class="k">return</span> <span class="n">item</span></div>
 </pre></div>

          </div>
@@ -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>

@@ -104,9 +104,9 @@ if it’s in the dict.  Aliases for functions not in the dict are ignored.</p>
 <dd><p>Given a quoted program on TOS and anything as the second stack item run
 the program and replace the two args with the first result of the
 program.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                                       <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app1</span>
 <span class="o">-----------------------------------</span>
-   <span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
+               <span class="o">...</span> <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -115,10 +115,10 @@ program.</p>
 <dt id="joy.library.app2">
 <code class="descclassname">joy.library.</code><code class="descname">app2</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app2"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app2" title="Permalink to this definition">¶</a></dt>
 <dd><p>Like app1 with two items.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>       <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                               <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app2</span>
 <span class="o">-----------------------------------</span>
-   <span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
-       <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
+               <span class="o">...</span> <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
+                               <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -127,11 +127,11 @@ program.</p>
 <dt id="joy.library.app3">
 <code class="descclassname">joy.library.</code><code class="descname">app3</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#app3"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.app3" title="Permalink to this definition">¶</a></dt>
 <dd><p>Like app1 with three items.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>       <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                               <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">app3</span>
 <span class="o">-----------------------------------</span>
-   <span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
-       <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
-       <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
+               <span class="o">...</span> <span class="p">[</span><span class="n">z</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span> <span class="n">first</span>
+                               <span class="p">[</span><span class="n">y</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
+                               <span class="p">[</span><span class="n">x</span> <span class="o">...</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span>   <span class="n">infra</span> <span class="n">first</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -154,13 +154,13 @@ program.</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">branch</span> <span class="o">==</span> <span class="n">roll</span><span class="o">&lt;</span> <span class="n">choice</span> <span class="n">i</span>
 </pre></div>
 </div>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>               <span class="kc">False</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
 <span class="o">--------------------------</span>
-          <span class="n">F</span>
+                                        <span class="n">F</span>

-   <span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
+               <span class="kc">True</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="n">branch</span>
 <span class="o">-------------------------</span>
-             <span class="n">T</span>
+                                                       <span class="n">T</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -169,14 +169,14 @@ program.</p>
 <dt id="joy.library.choice">
 <code class="descclassname">joy.library.</code><code class="descname">choice</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#choice"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.choice" title="Permalink to this definition">¶</a></dt>
 <dd><p>Use a Boolean value to select one of two items.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>               <span class="n">A</span> <span class="n">B</span> <span class="kc">False</span> <span class="n">choice</span>
 <span class="o">----------------------</span>
-          <span class="n">A</span>
+                                        <span class="n">A</span>


-   <span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
+               <span class="n">A</span> <span class="n">B</span> <span class="kc">True</span> <span class="n">choice</span>
 <span class="o">---------------------</span>
-          <span class="n">B</span>
+                                        <span class="n">B</span>
 </pre></div>
 </div>
 <p>Currently Python semantics are used to evaluate the “truthiness” of the
@@ -189,7 +189,7 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
 <dd><p>Clear everything from the stack.</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">clear</span> <span class="o">==</span> <span class="n">stack</span> <span class="p">[</span><span class="n">pop</span> <span class="n">stack</span><span class="p">]</span> <span class="n">loop</span>

-   <span class="o">...</span> <span class="n">clear</span>
+         <span class="o">...</span> <span class="n">clear</span>
 <span class="o">---------------</span>
 </pre></div>
 </div>
@@ -200,17 +200,17 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
 <code class="descclassname">joy.library.</code><code class="descname">cmp_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cmp_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cmp_" title="Permalink to this definition">¶</a></dt>
 <dd><p>cmp takes two values and three quoted programs on the stack and runs
 one of the three depending on the results of comparing the two values:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
 <span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span>
-        <span class="n">G</span>
+                                <span class="n">G</span>

-   <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
+         <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
 <span class="o">-------------------------</span> <span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
-            <span class="n">E</span>
+                                                <span class="n">E</span>

-   <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
+         <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">L</span><span class="p">]</span> <span class="nb">cmp</span>
 <span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span>
-                <span class="n">L</span>
+                                                                <span class="n">L</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -219,9 +219,9 @@ one of the three depending on the results of comparing the two values:</p>
 <dt id="joy.library.concat_">
 <code class="descclassname">joy.library.</code><code class="descname">concat_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#concat_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.concat_" title="Permalink to this definition">¶</a></dt>
 <dd><p>Concatinate the two lists on the top of the stack.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">concat</span>
 <span class="o">----------------------------</span>
-       <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span>
+                         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -235,9 +235,9 @@ default quote.  Each condition clause should contain a quoted predicate
 followed by the function expression to run if that predicate returns
 true.  If no predicates return true the default function runs.</p>
 <p>It works by rewriting into a chain of nested <cite>ifte</cite> expressions, e.g.:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>      <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                        <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
 <span class="o">-----------------------------------------</span>
-   <span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
+         <span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -248,9 +248,9 @@ true.  If no predicates return true the default function runs.</p>
 <dd><p>The dip combinator expects a quoted program on the stack and below it
 some item, it hoists the item into the expression and runs the program
 on the rest of the stack.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
 <span class="o">-------------------</span>
-     <span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
+                 <span class="o">...</span> <span class="n">Q</span> <span class="n">x</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -259,9 +259,9 @@ on the rest of the stack.</p>
 <dt id="joy.library.dipd">
 <code class="descclassname">joy.library.</code><code class="descname">dipd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipd" title="Permalink to this definition">¶</a></dt>
 <dd><p>Like dip but expects two items.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
 <span class="o">---------------------</span>
-     <span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
+                 <span class="o">...</span> <span class="n">Q</span> <span class="n">y</span> <span class="n">x</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -270,9 +270,9 @@ on the rest of the stack.</p>
 <dt id="joy.library.dipdd">
 <code class="descclassname">joy.library.</code><code class="descname">dipdd</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#dipdd"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.dipdd" title="Permalink to this definition">¶</a></dt>
 <dd><p>Like dip but expects three items.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">dip</span>
 <span class="o">-----------------------</span>
-     <span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
+                 <span class="o">...</span> <span class="n">Q</span> <span class="n">z</span> <span class="n">y</span> <span class="n">x</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -287,14 +287,20 @@ on the rest of the stack.</p>
 <dl class="function">
 <dt id="joy.library.drop">
 <code class="descclassname">joy.library.</code><code class="descname">drop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#drop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.drop" title="Permalink to this definition">¶</a></dt>
-<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
+<dd><blockquote>
+<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">drop</span> <span class="o">==</span> <span class="p">[</span><span class="n">rest</span><span class="p">]</span> <span class="n">times</span>
 </pre></div>
 </div>
 <p>Expects an integer and a quote on the stack and returns the quote with
 n items removed off the top.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">drop</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">drop</span>
 <span class="o">----------------------</span>
-       <span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
+                         <span class="p">[</span><span class="n">c</span> <span class="n">d</span><span class="p">]</span>
+</pre></div>
+</div>
+</div></blockquote>
+<p>Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -323,9 +329,9 @@ This is the largest integral value &lt;= x.</p>
 <dt id="joy.library.genrec">
 <code class="descclassname">joy.library.</code><code class="descname">genrec</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#genrec"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.genrec" title="Permalink to this definition">¶</a></dt>
 <dd><p>General Recursion Combinator.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                      <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                                                                                        <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span>
 <span class="o">---------------------------------------------------------------------</span>
-   <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span> <span class="p">[[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="n">rec2</span><span class="p">]</span> <span class="n">ifte</span>
+         <span class="p">[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span> <span class="p">[[</span><span class="k">if</span><span class="p">]</span> <span class="p">[</span><span class="n">then</span><span class="p">]</span> <span class="p">[</span><span class="n">rec1</span><span class="p">]</span> <span class="p">[</span><span class="n">rec2</span><span class="p">]</span> <span class="n">genrec</span><span class="p">]</span> <span class="n">rec2</span><span class="p">]</span> <span class="n">ifte</span>
 </pre></div>
 </div>
 <p>From “Recursion Theory and Joy” (j05cmp.html) by Manfred von Thun:
@@ -355,13 +361,13 @@ have to do to apply the quoted [F] in the proper way.  In effect, the
 genrec combinator turns into an ifte combinator with a quoted copy of
 the original definition in the else-part:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</span> <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span>   <span class="p">[</span><span class="n">R2</span><span class="p">]</span> <span class="n">genrec</span>
-  <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">R2</span><span class="p">]</span> <span class="n">ifte</span>
+        <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span> <span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="n">R2</span><span class="p">]</span> <span class="n">ifte</span>
 </pre></div>
 </div>
 <p>Primitive recursive functions are those where R2 == i.</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">P</span> <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span><span class="p">]</span> <span class="n">primrec</span>
-  <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">i</span><span class="p">]</span> <span class="n">ifte</span>
-  <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="n">P</span><span class="p">]</span> <span class="n">ifte</span>
+        <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="n">i</span><span class="p">]</span> <span class="n">ifte</span>
+        <span class="o">==</span> <span class="p">[</span><span class="n">I</span><span class="p">]</span> <span class="p">[</span><span class="n">T</span><span class="p">]</span> <span class="p">[</span><span class="n">R</span> <span class="n">P</span><span class="p">]</span> <span class="n">ifte</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -369,14 +375,20 @@ the original definition in the else-part:</p>
 <dl class="function">
 <dt id="joy.library.getitem">
 <code class="descclassname">joy.library.</code><code class="descname">getitem</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#getitem"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.getitem" title="Permalink to this definition">¶</a></dt>
-<dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
+<dd><blockquote>
+<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">getitem</span> <span class="o">==</span> <span class="n">drop</span> <span class="n">first</span>
 </pre></div>
 </div>
 <p>Expects an integer and a quote on the stack and returns the item at the
 nth position in the quote counting from 0.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">0</span> <span class="n">getitem</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">0</span> <span class="n">getitem</span>
 <span class="o">-------------------------</span>
-            <span class="n">a</span>
+                                                <span class="n">a</span>
+</pre></div>
+</div>
+</div></blockquote>
+<p>Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="n">a1</span><span class="p">)</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -392,9 +404,9 @@ nth position in the quote counting from 0.</p>
 <code class="descclassname">joy.library.</code><code class="descname">i</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#i"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.i" title="Permalink to this definition">¶</a></dt>
 <dd><p>The i combinator expects a quoted program on the stack and unpacks it
 onto the pending expression for evaluation.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">i</span>
 <span class="o">-----------</span>
-    <span class="n">Q</span>
+                <span class="n">Q</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -405,14 +417,20 @@ onto the pending expression for evaluation.</p>
 <dd><p>The identity function.</p>
 </dd></dl>

+<dl class="function">
+<dt id="joy.library.infer_">
+<code class="descclassname">joy.library.</code><code class="descname">infer_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infer_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infer_" title="Permalink to this definition">¶</a></dt>
+<dd><p>Attempt to infer the stack effect of a Joy expression.</p>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.library.infra">
 <code class="descclassname">joy.library.</code><code class="descname">infra</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#infra"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.infra" title="Permalink to this definition">¶</a></dt>
 <dd><p>Accept a quoted program and a list on the stack and run the program
-with the list as its stack.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
+with the list as its stack.  Does not affect the rest of the stack.</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">infra</span>
 <span class="o">-----------------------------</span>
-   <span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
+         <span class="n">c</span> <span class="n">b</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="n">swaack</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -429,17 +447,35 @@ with the list as its stack.</p>
 <dd><p>A decorator to inscribe functions into the default dictionary.</p>
 </dd></dl>

+<dl class="function">
+<dt id="joy.library.inscribe_">
+<code class="descclassname">joy.library.</code><code class="descname">inscribe_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#inscribe_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.inscribe_" title="Permalink to this definition">¶</a></dt>
+<dd><blockquote>
+<div><p>Create a new Joy function definition in the Joy dictionary.  A
+definition is given as a string with a name followed by a double
+equal sign then one or more Joy functions, the body. for example:</p>
+<blockquote>
+<div>sqr == dup mul</div></blockquote>
+<p>If you want the definition to persist over restarts, enter it into
+the definitions.txt resource.</p>
+</div></blockquote>
+<p>Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">t1</span> <span class="o">--</span><span class="p">)</span>
+</pre></div>
+</div>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.library.loop">
 <code class="descclassname">joy.library.</code><code class="descname">loop</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#loop"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.loop" title="Permalink to this definition">¶</a></dt>
 <dd><p>Basic loop combinator.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="kc">True</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
 <span class="o">-----------------------</span>
-      <span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
+                        <span class="o">...</span> <span class="n">Q</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>

-   <span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
+         <span class="o">...</span> <span class="kc">False</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">loop</span>
 <span class="o">------------------------</span>
-          <span class="o">...</span>
+                                        <span class="o">...</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -448,19 +484,27 @@ with the list as its stack.</p>
 <dt id="joy.library.map_">
 <code class="descclassname">joy.library.</code><code class="descname">map_</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#map_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.map_" title="Permalink to this definition">¶</a></dt>
 <dd><p>Run the quoted program on TOS on the items in the list under it, push a
-new list with the results (in place of the program and original list.</p>
+new list with the results in place of the program and original list.</p>
 </dd></dl>

 <dl class="function">
 <dt id="joy.library.max_">
 <code class="descclassname">joy.library.</code><code class="descname">max_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#max_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.max_" title="Permalink to this definition">¶</a></dt>
-<dd><p>Given a list find the maximum.</p>
+<dd><p>Given a list find the maximum.
+Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
+</pre></div>
+</div>
 </dd></dl>

 <dl class="function">
 <dt id="joy.library.min_">
 <code class="descclassname">joy.library.</code><code class="descname">min_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#min_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.min_" title="Permalink to this definition">¶</a></dt>
-<dd><p>Given a list find the minimum.</p>
+<dd><p>Given a list find the minimum.
+Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
+</pre></div>
+</div>
 </dd></dl>

 <dl class="function">
@@ -473,9 +517,9 @@ new list with the results (in place of the program and original list.</p>
 <dt id="joy.library.pm">
 <code class="descclassname">joy.library.</code><code class="descname">pm</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pm" title="Permalink to this definition">¶</a></dt>
 <dd><p>Plus or minus</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="n">a</span> <span class="n">b</span> <span class="n">pm</span>
 <span class="o">-------------</span>
-   <span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
+         <span class="n">a</span><span class="o">+</span><span class="n">b</span> <span class="n">a</span><span class="o">-</span><span class="n">b</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -483,7 +527,11 @@ new list with the results (in place of the program and original list.</p>
 <dl class="function">
 <dt id="joy.library.pred">
 <code class="descclassname">joy.library.</code><code class="descname">pred</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#pred"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.pred" title="Permalink to this definition">¶</a></dt>
-<dd><p>Decrement TOS.</p>
+<dd><p>Decrement TOS.
+Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
+</pre></div>
+</div>
 </dd></dl>

 <dl class="function">
@@ -491,9 +539,9 @@ new list with the results (in place of the program and original list.</p>
 <code class="descclassname">joy.library.</code><code class="descname">remove</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#remove"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.remove" title="Permalink to this definition">¶</a></dt>
 <dd><p>Expects an item on the stack and a quote under it and removes that item
 from the the quote.  The item is only removed once.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span> <span class="mi">1</span> <span class="n">remove</span>
 <span class="o">------------------------</span>
-        <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
+                                <span class="p">[</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">1</span><span class="p">]</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -511,14 +559,14 @@ from the the quote.  The item is only removed once.</p>
 <dt id="joy.library.select">
 <code class="descclassname">joy.library.</code><code class="descname">select</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#select"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.select" title="Permalink to this definition">¶</a></dt>
 <dd><p>Use a Boolean value to select one of two items from a sequence.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">False</span> <span class="n">select</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>               <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">False</span> <span class="n">select</span>
 <span class="o">------------------------</span>
-           <span class="n">A</span>
+                                               <span class="n">A</span>


-   <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
+               <span class="p">[</span><span class="n">A</span> <span class="n">B</span><span class="p">]</span> <span class="kc">True</span> <span class="n">select</span>
 <span class="o">-----------------------</span>
-          <span class="n">B</span>
+                                        <span class="n">B</span>
 </pre></div>
 </div>
 <p>The sequence can contain more than two items but not fewer.
@@ -538,9 +586,9 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
 <dd><p>Like concat but reverses the top list into the second.</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">shunt</span> <span class="o">==</span> <span class="p">[</span><span class="n">swons</span><span class="p">]</span> <span class="n">step</span> <span class="o">==</span> <span class="n">reverse</span> <span class="n">swap</span> <span class="n">concat</span>

-   <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
+         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">d</span> <span class="n">e</span> <span class="n">f</span><span class="p">]</span> <span class="n">shunt</span>
 <span class="o">---------------------------</span>
-     <span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> 
+                 <span class="p">[</span><span class="n">f</span> <span class="n">e</span> <span class="n">d</span> <span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> 
 </pre></div>
 </div>
 </dd></dl>
@@ -562,19 +610,19 @@ Negative numbers return complex roots.</p>
 <dt id="joy.library.step">
 <code class="descclassname">joy.library.</code><code class="descname">step</code><span class="sig-paren">(</span><em>S</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#step"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.step" title="Permalink to this definition">¶</a></dt>
 <dd><p>Run a quoted program on each item in a sequence.</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>      <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
-   <span class="o">-----------------------</span>
-             <span class="o">...</span> <span class="o">.</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>                        <span class="o">...</span> <span class="p">[]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
+         <span class="o">-----------------------</span>
+                                                 <span class="o">...</span> <span class="o">.</span>


-     <span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
-  <span class="o">------------------------</span>
-           <span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>
+                 <span class="o">...</span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
+        <span class="o">------------------------</span>
+                                         <span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span>


-   <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
+         <span class="o">...</span> <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">step</span>
 <span class="o">----------------------------------------</span>
-             <span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
+                                                 <span class="o">...</span> <span class="n">a</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">[</span><span class="n">b</span> <span class="n">c</span><span class="p">]</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">step</span>
 </pre></div>
 </div>
 <p>The step combinator executes the quotation on each member of the list
@@ -584,25 +632,40 @@ on top of the stack.</p>
 <dl class="function">
 <dt id="joy.library.succ">
 <code class="descclassname">joy.library.</code><code class="descname">succ</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#succ"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.succ" title="Permalink to this definition">¶</a></dt>
-<dd><p>Increment TOS.</p>
+<dd><p>Increment TOS.
+Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">n1</span> <span class="o">--</span> <span class="n">n2</span><span class="p">)</span>
+</pre></div>
+</div>
 </dd></dl>

 <dl class="function">
 <dt id="joy.library.sum_">
 <code class="descclassname">joy.library.</code><code class="descname">sum_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#sum_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.sum_" title="Permalink to this definition">¶</a></dt>
 <dd><p>Given a quoted sequence of numbers return the sum.</p>
-<p>sum == 0 swap [+] step</p>
+<blockquote>
+<div>sum == 0 swap [+] step</div></blockquote>
+<p>Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">n2</span><span class="o">*</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="o">--</span> <span class="n">n0</span><span class="p">)</span>
+</pre></div>
+</div>
 </dd></dl>

 <dl class="function">
 <dt id="joy.library.take">
 <code class="descclassname">joy.library.</code><code class="descname">take</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#take"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.take" title="Permalink to this definition">¶</a></dt>
-<dd><p>Expects an integer and a quote on the stack and returns the quote with
+<dd><blockquote>
+<div><p>Expects an integer and a quote on the stack and returns the quote with
 just the top n items in reverse order (because that’s easier and you can
 use reverse if needed.)</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="p">[</span><span class="n">a</span> <span class="n">b</span> <span class="n">c</span> <span class="n">d</span><span class="p">]</span> <span class="mi">2</span> <span class="n">take</span>
 <span class="o">----------------------</span>
-       <span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
+                         <span class="p">[</span><span class="n">b</span> <span class="n">a</span><span class="p">]</span>
+</pre></div>
+</div>
+</div></blockquote>
+<p>Stack effect:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="o">...</span><span class="mi">0</span><span class="p">]</span> <span class="n">i1</span> <span class="o">--</span> <span class="p">[</span><span class="o">...</span><span class="mi">1</span><span class="p">])</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -611,19 +674,19 @@ use reverse if needed.)</p>
 <dt id="joy.library.times">
 <code class="descclassname">joy.library.</code><code class="descname">times</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#times"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.times" title="Permalink to this definition">¶</a></dt>
 <dd><p>times == [– dip] cons [swap] infra [0 &gt;] swap while pop</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>         <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
 <span class="o">---------------------</span>  <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">0</span>
-         <span class="o">...</span> <span class="o">.</span>
+                                 <span class="o">...</span> <span class="o">.</span>


-   <span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
+         <span class="o">...</span> <span class="mi">1</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
 <span class="o">---------------------------------</span>
-         <span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>
+                                 <span class="o">...</span> <span class="o">.</span> <span class="n">Q</span>


-   <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
+         <span class="o">...</span> <span class="n">n</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="o">.</span> <span class="n">times</span>
 <span class="o">---------------------------------</span>  <span class="n">w</span><span class="o">/</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">1</span>
-         <span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
+                                 <span class="o">...</span> <span class="o">.</span> <span class="n">Q</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">[</span><span class="n">Q</span><span class="p">]</span> <span class="n">times</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -671,6 +734,15 @@ the stack discarding the rest of the stack.</p>
 </div>
 </dd></dl>

+<dl class="function">
+<dt id="joy.library.yin_functions">
+<code class="descclassname">joy.library.</code><code class="descname">yin_functions</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#yin_functions"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.yin_functions" title="Permalink to this definition">¶</a></dt>
+<dd><p>Return a dict of named stack effects.</p>
+<p>“Yin” functions are those that only rearrange items in stacks and
+can be defined completely by their stack effects.  This means they
+can be auto-compiled.</p>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.library.zip_">
 <code class="descclassname">joy.library.</code><code class="descname">zip_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#zip_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.zip_" title="Permalink to this definition">¶</a></dt>
@@ -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
@@ -43,10 +43,14 @@ expression as well as a single Symbol class and a single Exception type.</p>
 by the fact that they are not Symbol objects.</p>
 <p>A crude grammar:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span> <span class="o">=</span> <span class="n">term</span><span class="o">*</span>
-<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">function</span>
+<span class="n">term</span> <span class="o">=</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span> <span class="o">|</span> <span class="n">string</span> <span class="o">|</span> <span class="s1">&#39;[&#39;</span> <span class="n">joy</span> <span class="s1">&#39;]&#39;</span> <span class="o">|</span> <span class="n">symbol</span>
 </pre></div>
 </div>
-<p>A Joy expression is a sequence of zero or more terms</p>
+<p>A Joy expression is a sequence of zero or more terms.  A term is a
+literal value (integer, float, string, or Joy expression) or a function
+symbol.  Function symbols are unquoted strings and cannot contain square
+brackets.   Terms must be separated by blanks, which can be omitted
+around square brackets.</p>
 <dl class="exception">
 <dt id="joy.parser.ParseError">
 <em class="property">exception </em><code class="descclassname">joy.parser.</code><code class="descname">ParseError</code><a class="reference internal" href="_modules/joy/parser.html#ParseError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.parser.ParseError" title="Permalink to this definition">¶</a></dt>
@@ -70,11 +70,6 @@
       <td>&#160;&#160;&#160;
       <a href="library.html#module-joy.utils.generated_library"><code class="xref">joy.utils.generated_library</code></a></td><td>
       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="types.html#module-joy.utils.polytypes"><code class="xref">joy.utils.polytypes</code></a></td><td>
-       <em></em></td></tr>
     <tr class="cg-1">
       <td></td>
       <td>&#160;&#160;&#160;
@@ -59,7 +59,7 @@ form of a stack with one or more items on it:</p>
 means we can directly “unpack” the expected arguments to a Joy function.</p>
 <p>For example:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">((</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)):</span>
-  <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>We replace the argument “stack” by the expected structure of the stack,
@@ -71,8 +71,8 @@ where they would be redundant.)</p>
 web page, doesn’t handle tuples in the function parameters.  And in Python 3, this
 syntax was removed entirely.  Instead you would have to write:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dup</span><span class="p">(</span><span class="n">stack</span><span class="p">):</span>
-  <span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">stack</span>
-  <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
+        <span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">stack</span>
+        <span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="p">(</span><span class="n">head</span><span class="p">,</span> <span class="n">tail</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>We have two very simple functions, one to build up a stack from a Python
@@ -168,21 +168,21 @@ won’t work because <code class="docutils literal notranslate"><span class="pre

 <dl class="function">
 <dt id="joy.utils.stack.pick">
-<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>s</em>, <em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition">¶</a></dt>
+<code class="descclassname">joy.utils.stack.</code><code class="descname">pick</code><span class="sig-paren">(</span><em>stack</em>, <em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/stack.html#pick"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.stack.pick" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return the nth item on the stack.</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>s</strong> (<em>stack</em>) – A stack.</li>
+<li><strong>stack</strong> (<em>stack</em>) – A stack.</li>
 <li><strong>n</strong> (<em>int</em>) – An index into the stack.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><ul class="first simple">
 <li><strong>ValueError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is less than zero.</li>
-<li><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">s</span></code>.</li>
+<li><strong>IndexError</strong> – if <code class="docutils literal notranslate"><span class="pre">n</span></code> is equal to or greater than the length of <code class="docutils literal notranslate"><span class="pre">stack</span></code>.</li>
 </ul>
 </td>
 </tr>
@@ -117,6 +117,18 @@

 </dd></dl>

+<dl class="class">
+<dt id="joy.utils.types.CombinatorJoyType">
+<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">CombinatorJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em>, <em>expect=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#CombinatorJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.CombinatorJoyType" title="Permalink to this definition">¶</a></dt>
+<dd><p>Represent combinators.</p>
+<p>These type variables carry Joy functions that implement the
+behaviour of Joy combinators and they can appear in expressions.
+For simple combinators the implementation functions can be the
+combinators themselves.</p>
+<p>These types can also specify a stack effect (input side only) to
+guard against being used on invalid types.</p>
+</dd></dl>
+
 <dl class="class">
 <dt id="joy.utils.types.FloatJoyType">
 <em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FloatJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FloatJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FloatJoyType" title="Permalink to this definition">¶</a></dt>
@@ -128,6 +140,11 @@

 </dd></dl>

+<dl class="class">
+<dt id="joy.utils.types.FunctionJoyType">
+<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">FunctionJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#FunctionJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.FunctionJoyType" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
 <dl class="class">
 <dt id="joy.utils.types.IntJoyType">
 <em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">IntJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#IntJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.IntJoyType" title="Permalink to this definition">¶</a></dt>
@@ -144,6 +161,29 @@
 <em class="property">exception </em><code class="descclassname">joy.utils.types.</code><code class="descname">JoyTypeError</code><a class="reference internal" href="_modules/joy/utils/types.html#JoyTypeError"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.JoyTypeError" title="Permalink to this definition">¶</a></dt>
 <dd></dd></dl>

+<dl class="class">
+<dt id="joy.utils.types.KleeneStar">
+<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">KleeneStar</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#KleeneStar"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.KleeneStar" title="Permalink to this definition">¶</a></dt>
+<dd><p>A sequence of zero or more <cite>AnyJoyType</cite> variables would be:</p>
+<blockquote>
+<div>A*</div></blockquote>
+<p>The <cite>A*</cite> works by splitting the universe into two alternate histories:</p>
+<blockquote>
+<div><p>A* → ∅</p>
+<p>A* → A A*</p>
+</div></blockquote>
+<p>The Kleene star variable disappears in one universe, and in the other
+it turns into an <cite>AnyJoyType</cite> variable followed by itself again.</p>
+<p>We have to return all universes (represented by their substitution
+dicts, the “unifiers”) that don’t lead to type conflicts.</p>
+<dl class="attribute">
+<dt id="joy.utils.types.KleeneStar.kind">
+<code class="descname">kind</code><a class="headerlink" href="#joy.utils.types.KleeneStar.kind" title="Permalink to this definition">¶</a></dt>
+<dd><p>alias of <a class="reference internal" href="#joy.utils.types.AnyJoyType" title="joy.utils.types.AnyJoyType"><code class="xref py py-class docutils literal notranslate"><span class="pre">AnyJoyType</span></code></a></p>
+</dd></dl>
+
+</dd></dl>
+
 <dl class="class">
 <dt id="joy.utils.types.NumberJoyType">
 <em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">NumberJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#NumberJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.NumberJoyType" title="Permalink to this definition">¶</a></dt>
@@ -160,6 +200,25 @@

 </dd></dl>

+<dl class="class">
+<dt id="joy.utils.types.SymbolJoyType">
+<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">SymbolJoyType</code><span class="sig-paren">(</span><em>name</em>, <em>sec</em>, <em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#SymbolJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.SymbolJoyType" title="Permalink to this definition">¶</a></dt>
+<dd><p>Represent non-combinator functions.</p>
+<p>These type variables carry the stack effect comments and can
+appear in expressions (as in quoted programs.)</p>
+</dd></dl>
+
+<dl class="class">
+<dt id="joy.utils.types.TextJoyType">
+<em class="property">class </em><code class="descclassname">joy.utils.types.</code><code class="descname">TextJoyType</code><span class="sig-paren">(</span><em>number</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#TextJoyType"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.TextJoyType" title="Permalink to this definition">¶</a></dt>
+<dd><dl class="attribute">
+<dt id="joy.utils.types.TextJoyType.accept">
+<code class="descname">accept</code><a class="headerlink" href="#joy.utils.types.TextJoyType.accept" title="Permalink to this definition">¶</a></dt>
+<dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">__builtin__.basestring</span></code></p>
+</dd></dl>
+
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.utils.types.compilable">
 <code class="descclassname">joy.utils.types.</code><code class="descname">compilable</code><span class="sig-paren">(</span><em>f</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#compilable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.compilable" title="Permalink to this definition">¶</a></dt>
@@ -181,12 +240,6 @@ is used to generate one.</p>
 <dd><p>Return the stack effect of the composition of some of stack effects.</p>
 </dd></dl>

-<dl class="function">
-<dt id="joy.utils.types.defs">
-<code class="descclassname">joy.utils.types.</code><code class="descname">defs</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#defs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.defs" title="Permalink to this definition">¶</a></dt>
-<dd><p>Return a dict of named stack effects.</p>
-</dd></dl>
-
 <dl class="function">
 <dt id="joy.utils.types.delabel">
 <code class="descclassname">joy.utils.types.</code><code class="descname">delabel</code><span class="sig-paren">(</span><em>f</em>, <em>seen=None</em>, <em>c=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#delabel"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.delabel" title="Permalink to this definition">¶</a></dt>
@@ -195,10 +248,40 @@ is used to generate one.</p>

 <dl class="function">
 <dt id="joy.utils.types.doc_from_stack_effect">
-<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition">¶</a></dt>
+<code class="descclassname">joy.utils.types.</code><code class="descname">doc_from_stack_effect</code><span class="sig-paren">(</span><em>inputs</em>, <em>outputs=('??'</em>, <em>())</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#doc_from_stack_effect"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.doc_from_stack_effect" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return a crude string representation of a stack effect.</p>
 </dd></dl>

+<dl class="function">
+<dt id="joy.utils.types.infer">
+<code class="descclassname">joy.utils.types.</code><code class="descname">infer</code><span class="sig-paren">(</span><em>*expression</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#infer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.infer" title="Permalink to this definition">¶</a></dt>
+<dd><p>Return a list of stack effects for a Joy expression.</p>
+<p>For example:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">h</span> <span class="o">=</span> <span class="n">infer</span><span class="p">(</span><span class="n">pop</span><span class="p">,</span> <span class="n">swap</span><span class="p">,</span> <span class="n">rolldown</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">rest</span><span class="p">,</span> <span class="n">cons</span><span class="p">,</span> <span class="n">cons</span><span class="p">)</span>
+<span class="k">for</span> <span class="n">fi</span><span class="p">,</span> <span class="n">fo</span> <span class="ow">in</span> <span class="n">h</span><span class="p">:</span>
+                <span class="nb">print</span> <span class="n">doc_from_stack_effect</span><span class="p">(</span><span class="n">fi</span><span class="p">,</span> <span class="n">fo</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>Prints:</p>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">([</span><span class="n">a4</span> <span class="n">a5</span> <span class="o">...</span><span class="mi">1</span><span class="p">]</span> <span class="n">a3</span> <span class="n">a2</span> <span class="n">a1</span> <span class="o">--</span> <span class="p">[</span><span class="n">a2</span> <span class="n">a3</span> <span class="o">...</span><span class="mi">1</span><span class="p">])</span>
+</pre></div>
+</div>
+</dd></dl>
+
+<dl class="function">
+<dt id="joy.utils.types.meta_compose">
+<code class="descclassname">joy.utils.types.</code><code class="descname">meta_compose</code><span class="sig-paren">(</span><em>F</em>, <em>G</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#meta_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.meta_compose" title="Permalink to this definition">¶</a></dt>
+<dd><p>Yield the stack effects of the composition of two lists of stack
+effects.  An expression is carried along and updated and yielded.</p>
+</dd></dl>
+
+<dl class="function">
+<dt id="joy.utils.types.poly_compose">
+<code class="descclassname">joy.utils.types.</code><code class="descname">poly_compose</code><span class="sig-paren">(</span><em>f</em>, <em>g</em>, <em>e</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#poly_compose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.poly_compose" title="Permalink to this definition">¶</a></dt>
+<dd><p>Yield the stack effects of the composition of two stack effects.  An
+expression is carried along and updated and yielded.</p>
+</dd></dl>
+
 <dl class="function">
 <dt id="joy.utils.types.reify">
 <code class="descclassname">joy.utils.types.</code><code class="descname">reify</code><span class="sig-paren">(</span><em>meaning</em>, <em>name</em>, <em>seen=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#reify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.reify" title="Permalink to this definition">¶</a></dt>
@@ -212,8 +295,16 @@ is used to generate one.</p>
 </dd></dl>

 <dl class="function">
-<dt id="joy.utils.types.unify">
-<code class="descclassname">joy.utils.types.</code><code class="descname">unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.unify" title="Permalink to this definition">¶</a></dt>
+<dt id="joy.utils.types.type_check">
+<code class="descclassname">joy.utils.types.</code><code class="descname">type_check</code><span class="sig-paren">(</span><em>name</em>, <em>stack</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#type_check"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.type_check" title="Permalink to this definition">¶</a></dt>
+<dd><p>Trinary predicate.  True if named function type-checks, False if it
+fails, None if it’s indeterminate (because I haven’t entered it into
+the FUNCTIONS dict yet.)</p>
+</dd></dl>
+
+<dl class="function">
+<dt id="joy.utils.types.uni_unify">
+<code class="descclassname">joy.utils.types.</code><code class="descname">uni_unify</code><span class="sig-paren">(</span><em>u</em>, <em>v</em>, <em>s=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/utils/types.html#uni_unify"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.utils.types.uni_unify" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return a substitution dict representing a unifier for u and v.</p>
 </dd></dl>

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