about summary refs log tree commit diff stats
path: root/html/lambda-to-mu.mu.html
diff options
context:
space:
mode:
Diffstat (limited to 'html/lambda-to-mu.mu.html')
-rw-r--r--html/lambda-to-mu.mu.html104
1 files changed, 52 insertions, 52 deletions
diff --git a/html/lambda-to-mu.mu.html b/html/lambda-to-mu.mu.html
index 5041b306..2e0feb74 100644
--- a/html/lambda-to-mu.mu.html
+++ b/html/lambda-to-mu.mu.html
@@ -96,7 +96,7 @@ if ('onhashchange' in window) {
 <span id="L36" class="LineNr"> 36 </span><span class="Comment"># printed below as &lt; first | rest &gt;</span>
 <span id="L37" class="LineNr"> 37 </span><span class="muData">container</span> pair [
 <span id="L38" class="LineNr"> 38 </span>  first:&amp;:cell
-<span id="L39" class="LineNr"> 39 </span>  rest:&amp;:cell
+<span id="L39" class="LineNr"> 39 </span>  <a href='064list.mu.html#L25'>rest</a>:&amp;:cell
 <span id="L40" class="LineNr"> 40 </span>]
 <span id="L41" class="LineNr"> 41 </span>
 <span id="L42" class="LineNr"> 42 </span><span class="muRecipe">def</span> new-atom name:text<span class="muRecipe"> -&gt; </span>result:&amp;:cell [
@@ -178,12 +178,12 @@ if ('onhashchange' in window) {
 <span id="L118" class="LineNr">118 </span>  result <span class="Special">&lt;-</span> get pair, <span class="Constant">first:offset</span>
 <span id="L119" class="LineNr">119 </span>]
 <span id="L120" class="LineNr">120 </span>
-<span id="L121" class="LineNr">121 </span><span class="muRecipe">def</span> rest x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:&amp;:cell [
+<span id="L121" class="LineNr">121 </span><span class="muRecipe">def</span> <a href='064list.mu.html#L25'>rest</a> x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:&amp;:cell [
 <span id="L122" class="LineNr">122 </span>  <span class="Constant">local-scope</span>
 <span id="L123" class="LineNr">123 </span>  <span class="Constant">load-ingredients</span>
 <span id="L124" class="LineNr">124 </span>  pair:pair, pair?:bool <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">pair:variant</span>
 <span id="L125" class="LineNr">125 </span>  <span class="muControl">return-unless</span> pair?, <span class="Constant">0/nil</span>
-<span id="L126" class="LineNr">126 </span>  result <span class="Special">&lt;-</span> get pair, <span class="Constant">rest:offset</span>
+<span id="L126" class="LineNr">126 </span>  result <span class="Special">&lt;-</span> get pair, <span class="Constant"><a href='064list.mu.html#L25'>rest</a>:offset</span>
 <span id="L127" class="LineNr">127 </span>]
 <span id="L128" class="LineNr">128 </span>
 <span id="L129" class="LineNr">129 </span><span class="muRecipe">def</span> set-first base:&amp;:cell, new-first:&amp;:cell<span class="muRecipe"> -&gt; </span>base:&amp;:cell [
@@ -200,7 +200,7 @@ if ('onhashchange' in window) {
 <span id="L140" class="LineNr">140 </span>  <span class="Constant">load-ingredients</span>
 <span id="L141" class="LineNr">141 </span>  pair:pair, is-pair?:bool <span class="Special">&lt;-</span> maybe-convert *base, <span class="Constant">pair:variant</span>
 <span id="L142" class="LineNr">142 </span>  <span class="muControl">return-unless</span> is-pair?
-<span id="L143" class="LineNr">143 </span>  pair <span class="Special">&lt;-</span> put pair, <span class="Constant">rest:offset</span>, new-rest
+<span id="L143" class="LineNr">143 </span>  pair <span class="Special">&lt;-</span> put pair, <span class="Constant"><a href='064list.mu.html#L25'>rest</a>:offset</span>, new-rest
 <span id="L144" class="LineNr">144 </span>  *base <span class="Special">&lt;-</span> merge <span class="Constant">1/pair</span>, pair
 <span id="L145" class="LineNr">145 </span>]
 <span id="L146" class="LineNr">146 </span>
@@ -209,7 +209,7 @@ if ('onhashchange' in window) {
 <span id="L149" class="LineNr">149 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
 <span id="L150" class="LineNr">150 </span>  x:&amp;:cell <span class="Special">&lt;-</span> new-atom s
 <span id="L151" class="LineNr">151 </span>  10:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> first x
-<span id="L152" class="LineNr">152 </span>  11:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x
+<span id="L152" class="LineNr">152 </span>  11:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L153" class="LineNr">153 </span>  memory-should-contain [
 <span id="L154" class="LineNr">154 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># first is nil</span>
 <span id="L155" class="LineNr">155 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># rest is nil</span>
@@ -224,7 +224,7 @@ if ('onhashchange' in window) {
 <span id="L164" class="LineNr">164 </span>  y:&amp;:cell <span class="Special">&lt;-</span> new-pair x, <span class="Constant">0/nil</span>
 <span id="L165" class="LineNr">165 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> first y
 <span id="L166" class="LineNr">166 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> equal x, x2
-<span id="L167" class="LineNr">167 </span>  11:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest y
+<span id="L167" class="LineNr">167 </span>  11:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> y
 <span id="L168" class="LineNr">168 </span>  memory-should-contain [
 <span id="L169" class="LineNr">169 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># first is correct</span>
 <span id="L170" class="LineNr">170 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># rest is nil</span>
@@ -236,7 +236,7 @@ if ('onhashchange' in window) {
 <span id="L176" class="LineNr">176 </span><span class="muRecipe">def</span> parse in:text<span class="muRecipe"> -&gt; </span>out:&amp;:cell [
 <span id="L177" class="LineNr">177 </span>  <span class="Constant">local-scope</span>
 <span id="L178" class="LineNr">178 </span>  <span class="Constant">load-ingredients</span>
-<span id="L179" class="LineNr">179 </span>  s:&amp;:stream:char <span class="Special">&lt;-</span> new-stream in
+<span id="L179" class="LineNr">179 </span>  s:&amp;:stream:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L7'>new-stream</a> in
 <span id="L180" class="LineNr">180 </span>  out, s <span class="Special">&lt;-</span> parse s
 <span id="L181" class="LineNr">181 </span>  trace<span class="Constant"> 2</span>, <span class="Constant">[app/parse]</span>, out
 <span id="L182" class="LineNr">182 </span>]
@@ -246,27 +246,27 @@ if ('onhashchange' in window) {
 <span id="L186" class="LineNr">186 </span>  <span class="Constant">load-ingredients</span>
 <span id="L187" class="LineNr">187 </span>  <span class="Comment"># skip whitespace</span>
 <span id="L188" class="LineNr">188 </span>  in <span class="Special">&lt;-</span> skip-whitespace in
-<span id="L189" class="LineNr">189 </span>  c:char, eof?:bool <span class="Special">&lt;-</span> peek in
+<span id="L189" class="LineNr">189 </span>  c:char, eof?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L190" class="LineNr">190 </span>  <span class="muControl">return-if</span> eof?, <span class="Constant">0/nil</span>
 <span id="L191" class="LineNr">191 </span>  pair?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">40/open-paren</span>
 <span id="L192" class="LineNr">192 </span>  <span class="Delimiter">{</span>
 <span id="L193" class="LineNr">193 </span>    <span class="muControl">break-if</span> pair?
 <span id="L194" class="LineNr">194 </span>    <span class="Comment"># atom</span>
-<span id="L195" class="LineNr">195 </span>    buf:&amp;:buffer <span class="Special">&lt;-</span> new-buffer<span class="Constant"> 30</span>
+<span id="L195" class="LineNr">195 </span>    buf:&amp;:<a href='061text.mu.html#L127'>buffer</a> <span class="Special">&lt;-</span> <a href='061text.mu.html#L132'>new-buffer</a><span class="Constant"> 30</span>
 <span id="L196" class="LineNr">196 </span>    <span class="Delimiter">{</span>
-<span id="L197" class="LineNr">197 </span>      done?:bool <span class="Special">&lt;-</span> end-of-stream? in
+<span id="L197" class="LineNr">197 </span>      done?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L67'>end-of-stream?</a> in
 <span id="L198" class="LineNr">198 </span>      <span class="muControl">break-if</span> done?
 <span id="L199" class="LineNr">199 </span>      <span class="Comment"># stop before close paren or space</span>
-<span id="L200" class="LineNr">200 </span>      c:char <span class="Special">&lt;-</span> peek in
+<span id="L200" class="LineNr">200 </span>      c:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L201" class="LineNr">201 </span>      done? <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
 <span id="L202" class="LineNr">202 </span>      <span class="muControl">break-if</span> done?
-<span id="L203" class="LineNr">203 </span>      done? <span class="Special">&lt;-</span> space? c
+<span id="L203" class="LineNr">203 </span>      done? <span class="Special">&lt;-</span> <a href='061text.mu.html#L620'>space?</a> c
 <span id="L204" class="LineNr">204 </span>      <span class="muControl">break-if</span> done?
 <span id="L205" class="LineNr">205 </span>      c <span class="Special">&lt;-</span> read in
 <span id="L206" class="LineNr">206 </span>      buf <span class="Special">&lt;-</span> append buf, c
 <span id="L207" class="LineNr">207 </span>      <span class="muControl">loop</span>
 <span id="L208" class="LineNr">208 </span>    <span class="Delimiter">}</span>
-<span id="L209" class="LineNr">209 </span>    s:text <span class="Special">&lt;-</span> buffer-to-array buf
+<span id="L209" class="LineNr">209 </span>    s:text <span class="Special">&lt;-</span> <a href='061text.mu.html#L329'>buffer-to-array</a> buf
 <span id="L210" class="LineNr">210 </span>    out <span class="Special">&lt;-</span> new-atom s
 <span id="L211" class="LineNr">211 </span>  <span class="Delimiter">}</span>
 <span id="L212" class="LineNr">212 </span>  <span class="Delimiter">{</span>
@@ -276,10 +276,10 @@ if ('onhashchange' in window) {
 <span id="L216" class="LineNr">216 </span>    out <span class="Special">&lt;-</span> new <span class="Constant">cell:type</span>  <span class="Comment"># start out with nil</span>
 <span id="L217" class="LineNr">217 </span>    <span class="Comment"># read in first element of pair</span>
 <span id="L218" class="LineNr">218 </span>    <span class="Delimiter">{</span>
-<span id="L219" class="LineNr">219 </span>      end?:bool <span class="Special">&lt;-</span> end-of-stream? in
+<span id="L219" class="LineNr">219 </span>      end?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L67'>end-of-stream?</a> in
 <span id="L220" class="LineNr">220 </span>      not-end?:bool <span class="Special">&lt;-</span> not end?
 <span id="L221" class="LineNr">221 </span>      assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
-<span id="L222" class="LineNr">222 </span>      c <span class="Special">&lt;-</span> peek in
+<span id="L222" class="LineNr">222 </span>      c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L223" class="LineNr">223 </span>      close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
 <span id="L224" class="LineNr">224 </span>      <span class="muControl">break-if</span> close-paren?
 <span id="L225" class="LineNr">225 </span>      first:&amp;:cell, in <span class="Special">&lt;-</span> parse in
@@ -289,11 +289,11 @@ if ('onhashchange' in window) {
 <span id="L229" class="LineNr">229 </span>    curr:&amp;:cell <span class="Special">&lt;-</span> copy out
 <span id="L230" class="LineNr">230 </span>    <span class="Delimiter">{</span>
 <span id="L231" class="LineNr">231 </span>      in <span class="Special">&lt;-</span> skip-whitespace in
-<span id="L232" class="LineNr">232 </span>      end?:bool <span class="Special">&lt;-</span> end-of-stream? in
+<span id="L232" class="LineNr">232 </span>      end?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L67'>end-of-stream?</a> in
 <span id="L233" class="LineNr">233 </span>      not-end?:bool <span class="Special">&lt;-</span> not end?
 <span id="L234" class="LineNr">234 </span>      assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
 <span id="L235" class="LineNr">235 </span>      <span class="Comment"># termination check: ')'</span>
-<span id="L236" class="LineNr">236 </span>      c <span class="Special">&lt;-</span> peek in
+<span id="L236" class="LineNr">236 </span>      c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L237" class="LineNr">237 </span>      <span class="Delimiter">{</span>
 <span id="L238" class="LineNr">238 </span>        close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
 <span id="L239" class="LineNr">239 </span>        <span class="muControl">break-unless</span> close-paren?
@@ -301,19 +301,19 @@ if ('onhashchange' in window) {
 <span id="L241" class="LineNr">241 </span>        <span class="muControl">break</span> <span class="Constant">+end-pair</span>
 <span id="L242" class="LineNr">242 </span>      <span class="Delimiter">}</span>
 <span id="L243" class="LineNr">243 </span>      <span class="Comment"># still here? read next element of pair</span>
-<span id="L244" class="LineNr">244 </span>      next:&amp;:cell, in <span class="Special">&lt;-</span> parse in
-<span id="L245" class="LineNr">245 </span>      is-dot?:bool <span class="Special">&lt;-</span> atom-match? next, <span class="Constant">[.]</span>
+<span id="L244" class="LineNr">244 </span>      <a href='065duplex_list.mu.html#L29'>next</a>:&amp;:cell, in <span class="Special">&lt;-</span> parse in
+<span id="L245" class="LineNr">245 </span>      is-dot?:bool <span class="Special">&lt;-</span> atom-match? <a href='065duplex_list.mu.html#L29'>next</a>, <span class="Constant">[.]</span>
 <span id="L246" class="LineNr">246 </span>      <span class="Delimiter">{</span>
 <span id="L247" class="LineNr">247 </span>        <span class="muControl">break-if</span> is-dot?
-<span id="L248" class="LineNr">248 </span>        next-curr:&amp;:cell <span class="Special">&lt;-</span> new-pair next, <span class="Constant">0/nil</span>
+<span id="L248" class="LineNr">248 </span>        next-curr:&amp;:cell <span class="Special">&lt;-</span> new-pair <a href='065duplex_list.mu.html#L29'>next</a>, <span class="Constant">0/nil</span>
 <span id="L249" class="LineNr">249 </span>        curr <span class="Special">&lt;-</span> set-rest curr, next-curr
-<span id="L250" class="LineNr">250 </span>        curr <span class="Special">&lt;-</span> rest curr
+<span id="L250" class="LineNr">250 </span>        curr <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> curr
 <span id="L251" class="LineNr">251 </span>      <span class="Delimiter">}</span>
 <span id="L252" class="LineNr">252 </span>      <span class="Delimiter">{</span>
 <span id="L253" class="LineNr">253 </span>        <span class="muControl">break-unless</span> is-dot?
 <span id="L254" class="LineNr">254 </span>        <span class="Comment"># deal with dotted pair</span>
 <span id="L255" class="LineNr">255 </span>        in <span class="Special">&lt;-</span> skip-whitespace in
-<span id="L256" class="LineNr">256 </span>        c <span class="Special">&lt;-</span> peek in
+<span id="L256" class="LineNr">256 </span>        c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L257" class="LineNr">257 </span>        not-close-paren?:bool <span class="Special">&lt;-</span> not-equal c, <span class="Constant">41/close-paren</span>
 <span id="L258" class="LineNr">258 </span>        assert not-close-paren?, <span class="Constant">[')' cannot immediately follow '.']</span>
 <span id="L259" class="LineNr">259 </span>        final:&amp;:cell <span class="Special">&lt;-</span> parse in
@@ -321,7 +321,7 @@ if ('onhashchange' in window) {
 <span id="L261" class="LineNr">261 </span>        <span class="Comment"># we're not gonna update curr, so better make sure the next iteration</span>
 <span id="L262" class="LineNr">262 </span>        <span class="Comment"># is going to end the pair</span>
 <span id="L263" class="LineNr">263 </span>        in <span class="Special">&lt;-</span> skip-whitespace in
-<span id="L264" class="LineNr">264 </span>        c <span class="Special">&lt;-</span> peek in
+<span id="L264" class="LineNr">264 </span>        c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
 <span id="L265" class="LineNr">265 </span>        close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
 <span id="L266" class="LineNr">266 </span>        assert close-paren?, <span class="Constant">['.' must be followed by exactly one expression before ')']</span>
 <span id="L267" class="LineNr">267 </span>      <span class="Delimiter">}</span>
@@ -335,11 +335,11 @@ if ('onhashchange' in window) {
 <span id="L275" class="LineNr">275 </span>  <span class="Constant">local-scope</span>
 <span id="L276" class="LineNr">276 </span>  <span class="Constant">load-ingredients</span>
 <span id="L277" class="LineNr">277 </span>  <span class="Delimiter">{</span>
-<span id="L278" class="LineNr">278 </span>    done?:bool <span class="Special">&lt;-</span> end-of-stream? in
+<span id="L278" class="LineNr">278 </span>    done?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L67'>end-of-stream?</a> in
 <span id="L279" class="LineNr">279 </span>    <span class="muControl">return-if</span> done?, <span class="Constant">0/null</span>
-<span id="L280" class="LineNr">280 </span>    c:char <span class="Special">&lt;-</span> peek in
-<span id="L281" class="LineNr">281 </span>    space?:bool <span class="Special">&lt;-</span> space? c
-<span id="L282" class="LineNr">282 </span>    <span class="muControl">break-unless</span> space?
+<span id="L280" class="LineNr">280 </span>    c:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L39'>peek</a> in
+<span id="L281" class="LineNr">281 </span>    <a href='061text.mu.html#L620'>space?</a>:bool <span class="Special">&lt;-</span> <a href='061text.mu.html#L620'>space?</a> c
+<span id="L282" class="LineNr">282 </span>    <span class="muControl">break-unless</span> <a href='061text.mu.html#L620'>space?</a>
 <span id="L283" class="LineNr">283 </span>    read in  <span class="Comment"># skip</span>
 <span id="L284" class="LineNr">284 </span>    <span class="muControl">loop</span>
 <span id="L285" class="LineNr">285 </span>  <span class="Delimiter">}</span>
@@ -348,12 +348,12 @@ if ('onhashchange' in window) {
 <span id="L288" class="LineNr">288 </span><span class="muRecipe">def</span> to-text x:&amp;:cell<span class="muRecipe"> -&gt; </span>out:text [
 <span id="L289" class="LineNr">289 </span>  <span class="Constant">local-scope</span>
 <span id="L290" class="LineNr">290 </span>  <span class="Constant">load-ingredients</span>
-<span id="L291" class="LineNr">291 </span>  buf:&amp;:buffer <span class="Special">&lt;-</span> new-buffer<span class="Constant"> 30</span>
-<span id="L292" class="LineNr">292 </span>  buf <span class="Special">&lt;-</span> to-buffer x, buf
-<span id="L293" class="LineNr">293 </span>  out <span class="Special">&lt;-</span> buffer-to-array buf
+<span id="L291" class="LineNr">291 </span>  buf:&amp;:<a href='061text.mu.html#L127'>buffer</a> <span class="Special">&lt;-</span> <a href='061text.mu.html#L132'>new-buffer</a><span class="Constant"> 30</span>
+<span id="L292" class="LineNr">292 </span>  buf <span class="Special">&lt;-</span> <a href='064list.mu.html#L307'>to-buffer</a> x, buf
+<span id="L293" class="LineNr">293 </span>  out <span class="Special">&lt;-</span> <a href='061text.mu.html#L329'>buffer-to-array</a> buf
 <span id="L294" class="LineNr">294 </span>]
 <span id="L295" class="LineNr">295 </span>
-<span id="L296" class="LineNr">296 </span><span class="muRecipe">def</span> to-buffer x:&amp;:cell, buf:&amp;:buffer<span class="muRecipe"> -&gt; </span>buf:&amp;:buffer [
+<span id="L296" class="LineNr">296 </span><span class="muRecipe">def</span> <a href='064list.mu.html#L307'>to-buffer</a> x:&amp;:cell, buf:&amp;:<a href='061text.mu.html#L127'>buffer</a><span class="muRecipe"> -&gt; </span>buf:&amp;:<a href='061text.mu.html#L127'>buffer</a> [
 <span id="L297" class="LineNr">297 </span>  <span class="Constant">local-scope</span>
 <span id="L298" class="LineNr">298 </span>  <span class="Constant">load-ingredients</span>
 <span id="L299" class="LineNr">299 </span>  <span class="Comment"># base case: empty cell</span>
@@ -372,10 +372,10 @@ if ('onhashchange' in window) {
 <span id="L312" class="LineNr">312 </span>  <span class="Comment"># recursive case: pair</span>
 <span id="L313" class="LineNr">313 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[&lt; ]</span>
 <span id="L314" class="LineNr">314 </span>  first:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L315" class="LineNr">315 </span>  buf <span class="Special">&lt;-</span> to-buffer first, buf
+<span id="L315" class="LineNr">315 </span>  buf <span class="Special">&lt;-</span> <a href='064list.mu.html#L307'>to-buffer</a> first, buf
 <span id="L316" class="LineNr">316 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[ | ]</span>
-<span id="L317" class="LineNr">317 </span>  rest:&amp;:cell <span class="Special">&lt;-</span> rest x
-<span id="L318" class="LineNr">318 </span>  buf <span class="Special">&lt;-</span> to-buffer rest, buf
+<span id="L317" class="LineNr">317 </span>  <a href='064list.mu.html#L25'>rest</a>:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
+<span id="L318" class="LineNr">318 </span>  buf <span class="Special">&lt;-</span> <a href='064list.mu.html#L307'>to-buffer</a> <a href='064list.mu.html#L25'>rest</a>, buf
 <span id="L319" class="LineNr">319 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[ &gt;]</span>
 <span id="L320" class="LineNr">320 </span>]
 <span id="L321" class="LineNr">321 </span>
@@ -412,12 +412,12 @@ if ('onhashchange' in window) {
 <span id="L352" class="LineNr">352 </span>  ]
 <span id="L353" class="LineNr">353 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L354" class="LineNr">354 </span>  x1:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L355" class="LineNr">355 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L355" class="LineNr">355 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L356" class="LineNr">356 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
 <span id="L357" class="LineNr">357 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x2
 <span id="L358" class="LineNr">358 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> first x2
 <span id="L359" class="LineNr">359 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
-<span id="L360" class="LineNr">360 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x2
+<span id="L360" class="LineNr">360 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x2
 <span id="L361" class="LineNr">361 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L362" class="LineNr">362 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
 <span id="L363" class="LineNr">363 </span>  memory-should-contain [
@@ -440,12 +440,12 @@ if ('onhashchange' in window) {
 <span id="L380" class="LineNr">380 </span>  ]
 <span id="L381" class="LineNr">381 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L382" class="LineNr">382 </span>  x1:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L383" class="LineNr">383 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L383" class="LineNr">383 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L384" class="LineNr">384 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
 <span id="L385" class="LineNr">385 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x2
 <span id="L386" class="LineNr">386 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> first x2
 <span id="L387" class="LineNr">387 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
-<span id="L388" class="LineNr">388 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x2
+<span id="L388" class="LineNr">388 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x2
 <span id="L389" class="LineNr">389 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L390" class="LineNr">390 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
 <span id="L391" class="LineNr">391 </span>  memory-should-contain [
@@ -468,16 +468,16 @@ if ('onhashchange' in window) {
 <span id="L408" class="LineNr">408 </span>  ]
 <span id="L409" class="LineNr">409 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L410" class="LineNr">410 </span>  x1:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L411" class="LineNr">411 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L411" class="LineNr">411 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L412" class="LineNr">412 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
 <span id="L413" class="LineNr">413 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x2
 <span id="L414" class="LineNr">414 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> first x2
 <span id="L415" class="LineNr">415 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
-<span id="L416" class="LineNr">416 </span>  x4:&amp;:cell <span class="Special">&lt;-</span> rest x2
+<span id="L416" class="LineNr">416 </span>  x4:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x2
 <span id="L417" class="LineNr">417 </span>  14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x4
 <span id="L418" class="LineNr">418 </span>  x5:&amp;:cell <span class="Special">&lt;-</span> first x4
 <span id="L419" class="LineNr">419 </span>  s3:text, 15:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x5, <span class="Constant">atom:variant</span>
-<span id="L420" class="LineNr">420 </span>  16:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x4
+<span id="L420" class="LineNr">420 </span>  16:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x4
 <span id="L421" class="LineNr">421 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L422" class="LineNr">422 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
 <span id="L423" class="LineNr">423 </span>  40:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s3
@@ -507,8 +507,8 @@ if ('onhashchange' in window) {
 <span id="L447" class="LineNr">447 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L448" class="LineNr">448 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> first x1
 <span id="L449" class="LineNr">449 </span>  s1:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
-<span id="L450" class="LineNr">450 </span>  13:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x1
-<span id="L451" class="LineNr">451 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x
+<span id="L450" class="LineNr">450 </span>  13:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x1
+<span id="L451" class="LineNr">451 </span>  14:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L452" class="LineNr">452 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L453" class="LineNr">453 </span>  memory-should-contain [
 <span id="L454" class="LineNr">454 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
@@ -532,11 +532,11 @@ if ('onhashchange' in window) {
 <span id="L472" class="LineNr">472 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L473" class="LineNr">473 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> first x1
 <span id="L474" class="LineNr">474 </span>  s1:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
-<span id="L475" class="LineNr">475 </span>  13:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x1
-<span id="L476" class="LineNr">476 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L475" class="LineNr">475 </span>  13:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x1
+<span id="L476" class="LineNr">476 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L477" class="LineNr">477 </span>  x4:&amp;:cell <span class="Special">&lt;-</span> first x3
 <span id="L478" class="LineNr">478 </span>  s2:text, 14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x4, <span class="Constant">atom:variant</span>
-<span id="L479" class="LineNr">479 </span>  15:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x3
+<span id="L479" class="LineNr">479 </span>  15:&amp;:cell/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x3
 <span id="L480" class="LineNr">480 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L481" class="LineNr">481 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
 <span id="L482" class="LineNr">482 </span>  memory-should-contain [
@@ -584,7 +584,7 @@ if ('onhashchange' in window) {
 <span id="L524" class="LineNr">524 </span>  ]
 <span id="L525" class="LineNr">525 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L526" class="LineNr">526 </span>  x1:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L527" class="LineNr">527 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L527" class="LineNr">527 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L528" class="LineNr">528 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
 <span id="L529" class="LineNr">529 </span>  s2:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
 <span id="L530" class="LineNr">530 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
@@ -608,12 +608,12 @@ if ('onhashchange' in window) {
 <span id="L548" class="LineNr">548 </span>  ]
 <span id="L549" class="LineNr">549 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x
 <span id="L550" class="LineNr">550 </span>  x1:&amp;:cell <span class="Special">&lt;-</span> first x
-<span id="L551" class="LineNr">551 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> rest x
+<span id="L551" class="LineNr">551 </span>  x2:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x
 <span id="L552" class="LineNr">552 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
 <span id="L553" class="LineNr">553 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> is-pair? x2
 <span id="L554" class="LineNr">554 </span>  x3:&amp;:cell <span class="Special">&lt;-</span> first x2
 <span id="L555" class="LineNr">555 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
-<span id="L556" class="LineNr">556 </span>  x4:&amp;:cell <span class="Special">&lt;-</span> rest x2
+<span id="L556" class="LineNr">556 </span>  x4:&amp;:cell <span class="Special">&lt;-</span> <a href='064list.mu.html#L25'>rest</a> x2
 <span id="L557" class="LineNr">557 </span>  s3:text, 14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x4, <span class="Constant">atom:variant</span>
 <span id="L558" class="LineNr">558 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
 <span id="L559" class="LineNr">559 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
@@ -635,12 +635,12 @@ if ('onhashchange' in window) {
 <span id="L575" class="LineNr">575 </span><span class="muRecipe">def</span> to-mu in:&amp;:cell<span class="muRecipe"> -&gt; </span>out:text [
 <span id="L576" class="LineNr">576 </span>  <span class="Constant">local-scope</span>
 <span id="L577" class="LineNr">577 </span>  <span class="Constant">load-ingredients</span>
-<span id="L578" class="LineNr">578 </span>  buf:&amp;:buffer <span class="Special">&lt;-</span> new-buffer<span class="Constant"> 30</span>
+<span id="L578" class="LineNr">578 </span>  buf:&amp;:<a href='061text.mu.html#L127'>buffer</a> <span class="Special">&lt;-</span> <a href='061text.mu.html#L132'>new-buffer</a><span class="Constant"> 30</span>
 <span id="L579" class="LineNr">579 </span>  buf <span class="Special">&lt;-</span> to-mu in, buf
-<span id="L580" class="LineNr">580 </span>  out <span class="Special">&lt;-</span> buffer-to-array buf
+<span id="L580" class="LineNr">580 </span>  out <span class="Special">&lt;-</span> <a href='061text.mu.html#L329'>buffer-to-array</a> buf
 <span id="L581" class="LineNr">581 </span>]
 <span id="L582" class="LineNr">582 </span>
-<span id="L583" class="LineNr">583 </span><span class="muRecipe">def</span> to-mu in:&amp;:cell, buf:&amp;:buffer<span class="muRecipe"> -&gt; </span>buf:&amp;:buffer, result-name:text [
+<span id="L583" class="LineNr">583 </span><span class="muRecipe">def</span> to-mu in:&amp;:cell, buf:&amp;:<a href='061text.mu.html#L127'>buffer</a><span class="muRecipe"> -&gt; </span>buf:&amp;:<a href='061text.mu.html#L127'>buffer</a>, result-name:text [
 <span id="L584" class="LineNr">584 </span>  <span class="Constant">local-scope</span>
 <span id="L585" class="LineNr">585 </span>  <span class="Constant">load-ingredients</span>
 <span id="L586" class="LineNr">586 </span>  <span class="Comment"># null cell? no change.</span>