3491

Update the html, proving that commit 3490 worked. The only changes are
from other recent commits.

1 files changed, 60 insertions, 60 deletions

diff --git a/html/lambda-to-mu.mu.html b/html/lambda-to-mu.mu.html
index e591592b..52100115 100644
--- a/html/lambda-to-mu.mu.html
+++ b/html/lambda-to-mu.mu.html
@@ -83,14 +83,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   *result<span class="Special"> &lt;- </span>merge <span class="Constant">1/tag:pair</span>, a/first, b/rest
 ]
 
-<span class="muRecipe">def</span> is-atom? x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:boolean [
+<span class="muRecipe">def</span> is-atom? x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:bool [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   <span class="muControl">reply-unless</span> x, <span class="Constant">0/false</span>
   _, result<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
 ]
 
-<span class="muRecipe">def</span> is-pair? x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:boolean [
+<span class="muRecipe">def</span> is-pair? x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:bool [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   <span class="muControl">reply-unless</span> x, <span class="Constant">0/false</span>
@@ -101,8 +101,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Constant">local-scope</span>
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[a]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>new-atom s
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-atom? x
-  <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-atom? x
+  <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
     <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
@@ -115,18 +115,18 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[a]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>new-atom s
   y:&amp;:cell<span class="Special"> &lt;- </span>new-pair x, <span class="Constant">0/nil</span>
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-atom? y
-  <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? y
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-atom? y
+  <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>is-pair? y
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
     <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
   ]
 ]
 
-<span class="muRecipe">def</span> atom-match? x:&amp;:cell, pat:text<span class="muRecipe"> -&gt; </span>result:boolean [
+<span class="muRecipe">def</span> atom-match? x:&amp;:cell, pat:text<span class="muRecipe"> -&gt; </span>result:bool [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  s:text, is-atom?:boolean<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
+  s:text, is-atom?:bool<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
   <span class="muControl">reply-unless</span> is-atom?, <span class="Constant">0/false</span>
   result<span class="Special"> &lt;- </span>equal pat, s
 ]
@@ -134,7 +134,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muScenario">scenario</span> atom-match [
   <span class="Constant">local-scope</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>new-atom <span class="Constant">[abc]</span>
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>atom-match? x, <span class="Constant">[abc]</span>
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>atom-match? x, <span class="Constant">[abc]</span>
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
   ]
@@ -143,7 +143,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> first x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:&amp;:cell [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  pair:pair, pair?:boolean<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">pair:variant</span>
+  pair:pair, pair?:bool<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">pair:variant</span>
   <span class="muControl">reply-unless</span> pair?, <span class="Constant">0/nil</span>
   result<span class="Special"> &lt;- </span>get pair, <span class="Constant">first:offset</span>
 ]
@@ -151,7 +151,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> rest x:&amp;:cell<span class="muRecipe"> -&gt; </span>result:&amp;:cell [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  pair:pair, pair?:boolean<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">pair:variant</span>
+  pair:pair, pair?:bool<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">pair:variant</span>
   <span class="muControl">reply-unless</span> pair?, <span class="Constant">0/nil</span>
   result<span class="Special"> &lt;- </span>get pair, <span class="Constant">rest:offset</span>
 ]
@@ -159,7 +159,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> set-first base:&amp;:cell, new-first:&amp;:cell<span class="muRecipe"> -&gt; </span>base:&amp;:cell [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  pair:pair, is-pair?:boolean<span class="Special"> &lt;- </span>maybe-convert *base, <span class="Constant">pair:variant</span>
+  pair:pair, is-pair?:bool<span class="Special"> &lt;- </span>maybe-convert *base, <span class="Constant">pair:variant</span>
   <span class="muControl">reply-unless</span> is-pair?
   pair<span class="Special"> &lt;- </span>put pair, <span class="Constant">first:offset</span>, new-first
   *base<span class="Special"> &lt;- </span>merge <span class="Constant">1/pair</span>, pair
@@ -168,7 +168,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muRecipe">def</span> set-rest base:&amp;:cell, new-rest:&amp;:cell<span class="muRecipe"> -&gt; </span>base:&amp;:cell [
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
-  pair:pair, is-pair?:boolean<span class="Special"> &lt;- </span>maybe-convert *base, <span class="Constant">pair:variant</span>
+  pair:pair, is-pair?:bool<span class="Special"> &lt;- </span>maybe-convert *base, <span class="Constant">pair:variant</span>
   <span class="muControl">reply-unless</span> is-pair?
   pair<span class="Special"> &lt;- </span>put pair, <span class="Constant">rest:offset</span>, new-rest
   *base<span class="Special"> &lt;- </span>merge <span class="Constant">1/pair</span>, pair
@@ -193,7 +193,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   x:&amp;:cell<span class="Special"> &lt;- </span>new-atom s
   y:&amp;:cell<span class="Special"> &lt;- </span>new-pair x, <span class="Constant">0/nil</span>
   x2:&amp;:cell<span class="Special"> &lt;- </span>first y
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, x2
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>equal x, x2
   <span class="Constant">11</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest y
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># first is correct</span>
@@ -216,15 +216,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Constant">load-ingredients</span>
   <span class="Comment"># skip whitespace</span>
   in<span class="Special"> &lt;- </span>skip-whitespace in
-  c:char, eof?:boolean<span class="Special"> &lt;- </span>peek in
+  c:char, eof?:bool<span class="Special"> &lt;- </span>peek in
   <span class="muControl">reply-if</span> eof?, <span class="Constant">0/nil</span>
-  pair?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">40/open-paren</span>
+  pair?:bool<span class="Special"> &lt;- </span>equal c, <span class="Constant">40/open-paren</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-if</span> pair?
     <span class="Comment"># atom</span>
     b:&amp;:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">30</span>
     <span class="Delimiter">{</span>
-      done?:boolean<span class="Special"> &lt;- </span>end-of-stream? in
+      done?:bool<span class="Special"> &lt;- </span>end-of-stream? in
       <span class="muControl">break-if</span> done?
       <span class="Comment"># stop before close paren or space</span>
       c:char<span class="Special"> &lt;- </span>peek in
@@ -246,11 +246,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     out<span class="Special"> &lt;- </span>new <span class="Constant">cell:type</span>  <span class="Comment"># start out with nil</span>
     <span class="Comment"># read in first element of pair</span>
     <span class="Delimiter">{</span>
-      end?:boolean<span class="Special"> &lt;- </span>end-of-stream? in
-      not-end?:boolean<span class="Special"> &lt;- </span>not end?
+      end?:bool<span class="Special"> &lt;- </span>end-of-stream? in
+      not-end?:bool<span class="Special"> &lt;- </span>not end?
       assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
       c<span class="Special"> &lt;- </span>peek in
-      close-paren?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
+      close-paren?:bool<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
       <span class="muControl">break-if</span> close-paren?
       first:&amp;:cell, in<span class="Special"> &lt;- </span>parse in
       *out<span class="Special"> &lt;- </span>merge <span class="Constant">1/pair</span>, first, <span class="Constant">0/nil</span>
@@ -259,20 +259,20 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     curr:&amp;:cell<span class="Special"> &lt;- </span>copy out
     <span class="Delimiter">{</span>
       in<span class="Special"> &lt;- </span>skip-whitespace in
-      end?:boolean<span class="Special"> &lt;- </span>end-of-stream? in
-      not-end?:boolean<span class="Special"> &lt;- </span>not end?
+      end?:bool<span class="Special"> &lt;- </span>end-of-stream? in
+      not-end?:bool<span class="Special"> &lt;- </span>not end?
       assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
       <span class="Comment"># termination check: ')'</span>
       c<span class="Special"> &lt;- </span>peek in
       <span class="Delimiter">{</span>
-        close-paren?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
+        close-paren?:bool<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
         <span class="muControl">break-unless</span> close-paren?
         read in  <span class="Comment"># skip ')'</span>
         <span class="muControl">break</span> <span class="Constant">+end-pair:label</span>
       <span class="Delimiter">}</span>
       <span class="Comment"># still here? read next element of pair</span>
       next:&amp;:cell, in<span class="Special"> &lt;- </span>parse in
-      is-dot?:boolean<span class="Special"> &lt;- </span>atom-match? next, <span class="Constant">[.]</span>
+      is-dot?:bool<span class="Special"> &lt;- </span>atom-match? next, <span class="Constant">[.]</span>
       <span class="Delimiter">{</span>
         <span class="muControl">break-if</span> is-dot?
         next-curr:&amp;:cell<span class="Special"> &lt;- </span>new-pair next, <span class="Constant">0/nil</span>
@@ -284,7 +284,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
         <span class="Comment"># deal with dotted pair</span>
         in<span class="Special"> &lt;- </span>skip-whitespace in
         c<span class="Special"> &lt;- </span>peek in
-        not-close-paren?:boolean<span class="Special"> &lt;- </span>not-equal c, <span class="Constant">41/close-paren</span>
+        not-close-paren?:bool<span class="Special"> &lt;- </span>not-equal c, <span class="Constant">41/close-paren</span>
         assert not-close-paren?, <span class="Constant">[')' cannot immediately follow '.']</span>
         final:&amp;:cell<span class="Special"> &lt;- </span>parse in
         curr<span class="Special"> &lt;- </span>set-rest curr, final
@@ -292,7 +292,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
         <span class="Comment"># is going to end the pair</span>
         in<span class="Special"> &lt;- </span>skip-whitespace in
         c<span class="Special"> &lt;- </span>peek in
-        close-paren?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
+        close-paren?:bool<span class="Special"> &lt;- </span>equal c, <span class="Constant">41/close-paren</span>
         assert close-paren?, <span class="Constant">['.' must be followed by exactly one expression before ')']</span>
       <span class="Delimiter">}</span>
       <span class="muControl">loop</span>
@@ -305,10 +305,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Constant">local-scope</span>
   <span class="Constant">load-ingredients</span>
   <span class="Delimiter">{</span>
-    done?:boolean<span class="Special"> &lt;- </span>end-of-stream? in
+    done?:bool<span class="Special"> &lt;- </span>end-of-stream? in
     <span class="muControl">reply-if</span> done?, <span class="Constant">0/null</span>
     c:char<span class="Special"> &lt;- </span>peek in
-    space?:boolean<span class="Special"> &lt;- </span>space? c
+    space?:bool<span class="Special"> &lt;- </span>space? c
     <span class="muControl">break-unless</span> space?
     read in  <span class="Comment"># skip</span>
     <span class="muControl">loop</span>
@@ -334,7 +334,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Delimiter">}</span>
   <span class="Comment"># base case: atom</span>
   <span class="Delimiter">{</span>
-    s:text, atom?:boolean<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
+    s:text, atom?:bool<span class="Special"> &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
     <span class="muControl">break-unless</span> atom?
     buf<span class="Special"> &lt;- </span>append buf, s
     <span class="muControl">reply</span>
@@ -353,7 +353,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Constant">local-scope</span>
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[a]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
-  s2:text, <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
   <span class="Constant">11</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># parse result is an atom</span>
@@ -365,7 +365,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   <span class="Constant">local-scope</span>
   s:text<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
   x:&amp;:cell<span class="Special"> &lt;- </span>parse s
-  s2:text, <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x, <span class="Constant">atom:variant</span>
   <span class="Constant">11</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
   memory-should-contain [
     <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># parse result is an atom</span>
@@ -380,13 +380,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; abc | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
   x2:&amp;:cell<span class="Special"> &lt;- </span>rest x
-  s1:text, <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
-  <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x2
+  s1:text, <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
+  <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x2
   x3:&amp;:cell<span class="Special"> &lt;- </span>first x2
-  s2:text, <span class="Constant">13</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">13</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
   <span class="Constant">14</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x2
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
@@ -408,13 +408,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; abc | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
   x2:&amp;:cell<span class="Special"> &lt;- </span>rest x
-  s1:text, <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
-  <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x2
+  s1:text, <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
+  <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x2
   x3:&amp;:cell<span class="Special"> &lt;- </span>first x2
-  s2:text, <span class="Constant">13</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">13</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
   <span class="Constant">14</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x2
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
@@ -436,17 +436,17 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; abc | &lt; def | &lt; ghi | <span class="Constant">&lt;&gt;</span> &gt; &gt; &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
   x2:&amp;:cell<span class="Special"> &lt;- </span>rest x
-  s1:text, <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
-  <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x2
+  s1:text, <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
+  <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x2
   x3:&amp;:cell<span class="Special"> &lt;- </span>first x2
-  s2:text, <span class="Constant">13</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">13</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
   x4:&amp;:cell<span class="Special"> &lt;- </span>rest x2
-  <span class="Constant">14</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x4
+  <span class="Constant">14</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x4
   x5:&amp;:cell<span class="Special"> &lt;- </span>first x4
-  s3:text, <span class="Constant">15</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x5, <span class="Constant">atom:variant</span>
+  s3:text, <span class="Constant">15</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x5, <span class="Constant">atom:variant</span>
   <span class="Constant">16</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x4
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
@@ -472,11 +472,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; &lt; abc | <span class="Constant">&lt;&gt;</span> &gt; | <span class="Constant">&lt;&gt;</span> &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
-  <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x2:&amp;:cell<span class="Special"> &lt;- </span>first x1
-  s1:text, <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
+  s1:text, <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
   <span class="Constant">13</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x1
   <span class="Constant">14</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
@@ -497,15 +497,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; &lt; abc | <span class="Constant">&lt;&gt;</span> &gt; | &lt; def | <span class="Constant">&lt;&gt;</span> &gt; &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
-  <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x2:&amp;:cell<span class="Special"> &lt;- </span>first x1
-  s1:text, <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
+  s1:text, <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
   <span class="Constant">13</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x1
   x3:&amp;:cell<span class="Special"> &lt;- </span>rest x
   x4:&amp;:cell<span class="Special"> &lt;- </span>first x3
-  s2:text, <span class="Constant">14</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x4, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">14</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x4, <span class="Constant">atom:variant</span>
   <span class="Constant">15</span>:&amp;:cell/<span class="Special">raw &lt;- </span>rest x3
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
@@ -552,11 +552,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; abc | def &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
   x2:&amp;:cell<span class="Special"> &lt;- </span>rest x
-  s1:text, <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
-  s2:text, <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
+  s1:text, <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x2, <span class="Constant">atom:variant</span>
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
   memory-should-contain [
@@ -576,15 +576,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   trace-should-contain [
     app/parse: &lt; abc | &lt; def | ghi &gt; &gt;
   ]
-  <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x
+  <span class="Constant">10</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x
   x1:&amp;:cell<span class="Special"> &lt;- </span>first x
   x2:&amp;:cell<span class="Special"> &lt;- </span>rest x
-  s1:text, <span class="Constant">11</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
-  <span class="Constant">12</span>:boolean/<span class="Special">raw &lt;- </span>is-pair? x2
+  s1:text, <span class="Constant">11</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x1, <span class="Constant">atom:variant</span>
+  <span class="Constant">12</span>:bool/<span class="Special">raw &lt;- </span>is-pair? x2
   x3:&amp;:cell<span class="Special"> &lt;- </span>first x2
-  s2:text, <span class="Constant">13</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
+  s2:text, <span class="Constant">13</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x3, <span class="Constant">atom:variant</span>
   x4:&amp;:cell<span class="Special"> &lt;- </span>rest x2
-  s3:text, <span class="Constant">14</span>:boolean/<span class="Special">raw &lt;- </span>maybe-convert *x4, <span class="Constant">atom:variant</span>
+  s3:text, <span class="Constant">14</span>:bool/<span class="Special">raw &lt;- </span>maybe-convert *x4, <span class="Constant">atom:variant</span>
   <span class="Constant">20</span>:@:char/<span class="Special">raw &lt;- </span>copy *s1
   <span class="Constant">30</span>:@:char/<span class="Special">raw &lt;- </span>copy *s2
   <span class="Constant">40</span>:@:char/<span class="Special">raw &lt;- </span>copy *s3