Minor docs cleanup.

docs/sphinx_docs/_build/html/_modules/joy/library.html

@@ -1177,14 +1177,17 @@
 <span class="nd">@FunctionWrapper</span>
 <span class="k">def</span> <span class="nf">cond</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
   <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">  like a case statement; works by rewriting into a chain of ifte.</span>
+<span class="sd">  This combinator works like a case statement.  It expects a single quote</span>
+<span class="sd">  on the stack that must contain zero or more condition quotes and a </span>
+<span class="sd">  default quote.  Each condition clause should contain a quoted predicate</span>
+<span class="sd">  followed by the function expression to run if that predicate returns</span>
+<span class="sd">  true.  If no predicates return true the default function runs.</span>
 
-<span class="sd">  [..[[Bi] Ti]..[D]] -&gt; ...</span>
+<span class="sd">  It works by rewriting into a chain of nested `ifte` expressions, e.g.::</span>
 
-
-<span class="sd">        [[[B0] T0] [[B1] T1] [D]] cond</span>
-<span class="sd">  -----------------------------------------</span>
-<span class="sd">     [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
+<span class="sd">            [[[B0] T0] [[B1] T1] [D]] cond</span>
+<span class="sd">      -----------------------------------------</span>
+<span class="sd">         [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
 
 <span class="sd">  &#39;&#39;&#39;</span>
   <span class="n">conditions</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1433,9 +1436,10 @@
 <div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
 <span class="nd">@FunctionWrapper</span>
 <span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
-    <span class="sd">&#39;&#39;&#39;</span>
-<span class="sd">    cmp takes two values and three quoted programs on the stack and runs</span>
-<span class="sd">    one of the three depending on the results of comparing the two values:</span>
+  <span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">  cmp takes two values and three quoted programs on the stack and runs</span>
+<span class="sd">  one of the three depending on the results of comparing the two values:</span>
+<span class="sd">  ::</span>
 
 <span class="sd">           a b [G] [E] [L] cmp</span>
 <span class="sd">        ------------------------- a &gt; b</span>
@@ -1448,10 +1452,10 @@
 <span class="sd">           a b [G] [E] [L] cmp</span>
 <span class="sd">        ------------------------- a &lt; b</span>
 <span class="sd">                        L</span>
-<span class="sd">    &#39;&#39;&#39;</span>
-    <span class="n">L</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">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
-    <span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</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="sd">  &#39;&#39;&#39;</span>
+  <span class="n">L</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">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
+  <span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</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="c1">#def nullary(S, expression, dictionary):</span>

docs/sphinx_docs/_build/html/index.html

@@ -135,6 +135,7 @@ interesting aspects.  It’s quite a treasure trove.</p>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Replacing.html">Replacing Functions in the Dictionary</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebooks/Generator Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Newton-Raphson.html">Newton’s method</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/Quadratic.html">Quadratic formula</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebooks/NoUpdates.html">No Updates</a></li>

docs/sphinx_docs/_build/html/library.html

@@ -198,24 +198,19 @@ 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>
-<blockquote>
-<div><blockquote>
-<div>a b [G] [E] [L] cmp</div></blockquote>
-<dl class="docutils">
-<dt>————————- a &gt; b</dt>
-<dd><blockquote class="first">
-<div>G</div></blockquote>
-<p class="last">a b [G] [E] [L] cmp</p>
-</dd>
-<dt>————————- a = b</dt>
-<dd><blockquote class="first">
-<div>E</div></blockquote>
-<p class="last">a b [G] [E] [L] cmp</p>
-</dd>
-<dt>————————- a &lt; b</dt>
-<dd>L</dd>
-</dl>
-</div></blockquote>
+<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">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">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>
+</pre></div>
+</div>
 </dd></dl>
 
 <dl class="function">
@@ -227,12 +222,17 @@ one of the three depending on the results of comparing the two values:</p>
 <dl class="function">
 <dt id="joy.library.cond">
 <code class="descclassname">joy.library.</code><code class="descname">cond</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#cond"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cond" title="Permalink to this definition">¶</a></dt>
-<dd><p>like a case statement; works by rewriting into a chain of ifte.</p>
-<p>[..[[Bi] Ti]..[D]] -&gt; …</p>
-<blockquote>
-<div>[[[B0] T0] [[B1] T1] [D]] cond</div></blockquote>
-<blockquote>
-<div>[B0] [T0] [[B1] [T1] [D] ifte] ifte</div></blockquote>
+<dd><p>This combinator works like a case statement.  It expects a single quote
+on the stack that must contain zero or more condition quotes and a 
+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>
+<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>
+</pre></div>
+</div>
 </dd></dl>
 
 <dl class="function">

docs/sphinx_docs/_build/html/notebooks/index.html

@@ -73,6 +73,17 @@
 <li class="toctree-l2"><a class="reference internal" href="Treestep.html#putting-it-together">Putting it together</a></li>
 </ul>
 </li>
+<li class="toctree-l1"><a class="reference internal" href="Generator Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#direco"><code class="docutils literal notranslate"><span class="pre">direco</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#making-generators">Making Generators</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#generating-multiples-of-three-and-five">Generating Multiples of Three and Five</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#project-euler-problem-one">Project Euler Problem One</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#a-generator-for-the-fibonacci-sequence">A generator for the Fibonacci Sequence.</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#project-euler-problem-two">Project Euler Problem Two</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#how-to-compile-these">How to compile these?</a></li>
+<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#an-interesting-variation">An Interesting Variation</a></li>
+</ul>
+</li>
 <li class="toctree-l1"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#a-generator-for-approximations">A Generator for Approximations</a></li>
 <li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#finding-consecutive-approximations-within-a-tolerance">Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance</a></li>