about summary refs log tree commit diff stats
path: root/html/071print.mu.html
diff options
context:
space:
mode:
authorKartik K. Agaram <vc@akkartik.com>2015-09-07 10:37:27 -0700
committerKartik K. Agaram <vc@akkartik.com>2015-09-07 10:37:27 -0700
commitf5465e1220d73e237c51897b7d1211ec53b0dc04 (patch)
tree939ee8e57241b8515aede8106c6420e330ace75a /html/071print.mu.html
parent5ccf2653fb7d31b013f77df4e92e964e45c54f8a (diff)
downloadmu-f5465e1220d73e237c51897b7d1211ec53b0dc04.tar.gz
2177
Diffstat (limited to 'html/071print.mu.html')
-rw-r--r--html/071print.mu.html954
1 files changed, 479 insertions, 475 deletions
diff --git a/html/071print.mu.html b/html/071print.mu.html
index ce70d068..c4334f55 100644
--- a/html/071print.mu.html
+++ b/html/071print.mu.html
@@ -13,10 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.Special { color: #ff6060; }
+.muRecipe { color: #ff8700; }
+.muData { color: #ffff00; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
-.Underlined { color: #c000c0; text-decoration: underline; }
-.Identifier { color: #804000; }
+.Constant { color: #00a0a0; }
+.Special { color: #ff6060; }
+.Delimiter { color: #a04060; }
+.muControl { color: #c0a020; }
 -->
 </style>
 
@@ -31,686 +35,686 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># Wrappers around print primitives that take a 'screen' object and are thus</span>
 <span class="Comment"># easier to test.</span>
 
-container screen [
+<span class="muData">container</span> screen [
   num-rows:number
   num-columns:number
   cursor-row:number
   cursor-column:number
-  data:address:<span class="Identifier">array</span>:screen-cell
+  data:address:array:screen-cell
 ]
 
-container screen-cell [
+<span class="muData">container</span> screen-cell [
   contents:character
   color:number
 ]
 
-recipe <span class="Identifier">new</span>-fake-screen [
-  <span class="Underlined">local</span>-scope
-  result:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span> screen:<span class="Identifier">type</span>
-  width:address:number<span class="Special"> &lt;- </span>get-address *result, num-columns:offset
-  *width<span class="Special"> &lt;- </span>next-ingredient
-  height:address:number<span class="Special"> &lt;- </span>get-address *result, num-rows:offset
-  *height<span class="Special"> &lt;- </span>next-ingredient
-  row:address:number<span class="Special"> &lt;- </span>get-address *result, cursor-row:offset
-  *row<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-  column:address:number<span class="Special"> &lt;- </span>get-address *result, cursor-column:offset
-  *column<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
+<span class="muRecipe">recipe</span> new-fake-screen [
+  <span class="Constant">local-scope</span>
+  result:address:screen<span class="Special"> &lt;- </span>new <span class="Constant">screen:type</span>
+  width:address:number<span class="Special"> &lt;- </span>get-address *result, <span class="Constant">num-columns:offset</span>
+  *width<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  height:address:number<span class="Special"> &lt;- </span>get-address *result, <span class="Constant">num-rows:offset</span>
+  *height<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  row:address:number<span class="Special"> &lt;- </span>get-address *result, <span class="Constant">cursor-row:offset</span>
+  *row<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+  column:address:number<span class="Special"> &lt;- </span>get-address *result, <span class="Constant">cursor-column:offset</span>
+  *column<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   bufsize:number<span class="Special"> &lt;- </span>multiply *width, *height
-  buf:address:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get-address *result, data:offset
-  *buf<span class="Special"> &lt;- </span><span class="Identifier">new</span> screen-cell:<span class="Identifier">type</span>, bufsize
+  buf:address:address:array:screen-cell<span class="Special"> &lt;- </span>get-address *result, <span class="Constant">data:offset</span>
+  *buf<span class="Special"> &lt;- </span>new <span class="Constant">screen-cell:type</span>, bufsize
   clear-screen result
-  reply result
+  <span class="muControl">reply</span> result
 ]
 
-recipe clear-screen [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> clear-screen [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists</span>
-  {
-    break-unless sc
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
     <span class="Comment"># clear fake screen</span>
-    buf:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *sc, data:offset
-    <span class="Identifier">max</span>:number<span class="Special"> &lt;- </span><span class="Identifier">length</span> *buf
-    i:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-    {
-      done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, <span class="Identifier">max</span>
-      break-if done?
+    buf:address:array:screen-cell<span class="Special"> &lt;- </span>get *sc, <span class="Constant">data:offset</span>
+    max:number<span class="Special"> &lt;- </span>length *buf
+    i:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+    <span class="Delimiter">{</span>
+      done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, max
+      <span class="muControl">break-if</span> done?
       curr:address:screen-cell<span class="Special"> &lt;- </span>index-address *buf, i
-      curr-<span class="Identifier">content</span>:address:character<span class="Special"> &lt;- </span>get-address *curr, contents:offset
-      *curr-<span class="Identifier">content</span><span class="Special"> &lt;- </span><span class="Identifier">copy</span> [ ]
-      curr-color:address:character<span class="Special"> &lt;- </span>get-address *curr, color:offset
-      *curr-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 7/white
-      i<span class="Special"> &lt;- </span>add i, 1
-      loop
-    }
+      curr-content:address:character<span class="Special"> &lt;- </span>get-address *curr, <span class="Constant">contents:offset</span>
+      *curr-content<span class="Special"> &lt;- </span>copy <span class="Constant">[ ]</span>
+      curr-color:address:character<span class="Special"> &lt;- </span>get-address *curr, <span class="Constant">color:offset</span>
+      *curr-color<span class="Special"> &lt;- </span>copy <span class="Constant">7/white</span>
+      i<span class="Special"> &lt;- </span>add i, <span class="Constant">1</span>
+      <span class="muControl">loop</span>
+    <span class="Delimiter">}</span>
     <span class="Comment"># reset cursor</span>
-    x:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-row:offset
-    *x<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-    x<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-    *x<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-    reply sc/same-as-ingredient:0
-  }
+    x:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-row:offset</span>
+    *x<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+    x<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+    *x<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   clear-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe sync-screen [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
-  {
-    break-if sc
+<span class="muRecipe">recipe</span> sync-screen [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-if</span> sc
     sync-display
-  }
+  <span class="Delimiter">}</span>
   <span class="Comment"># do nothing for fake screens</span>
 ]
 
-recipe fake-screen-<span class="Identifier">is</span>-empty? [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
-  reply-unless sc, 1/true
-  buf:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *sc, data:offset
-  i:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-  len:number<span class="Special"> &lt;- </span><span class="Identifier">length</span> *buf
-  {
+<span class="muRecipe">recipe</span> fake-screen-is-empty? [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="muControl">reply-unless</span> sc, <span class="Constant">1/true</span>
+  buf:address:array:screen-cell<span class="Special"> &lt;- </span>get *sc, <span class="Constant">data:offset</span>
+  i:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+  len:number<span class="Special"> &lt;- </span>length *buf
+  <span class="Delimiter">{</span>
     done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, len
-    break-if done?
+    <span class="muControl">break-if</span> done?
     curr:screen-cell<span class="Special"> &lt;- </span>index *buf, i
-    curr-contents:character<span class="Special"> &lt;- </span>get curr, contents:offset
-    i<span class="Special"> &lt;- </span>add i, 1
-    loop-unless curr-contents
+    curr-contents:character<span class="Special"> &lt;- </span>get curr, <span class="Constant">contents:offset</span>
+    i<span class="Special"> &lt;- </span>add i, <span class="Constant">1</span>
+    <span class="muControl">loop-unless</span> curr-contents
     <span class="Comment"># not 0</span>
-    reply 0/false
-  }
-  reply 1/true
+    <span class="muControl">reply</span> <span class="Constant">0/false</span>
+  <span class="Delimiter">}</span>
+  <span class="muControl">reply</span> <span class="Constant">1/true</span>
 ]
 
-recipe <span class="Identifier">print</span>-character [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
-  c:character<span class="Special"> &lt;- </span>next-ingredient
-  color:number, color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+<span class="muRecipe">recipe</span> print-character [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  c:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default color to white</span>
-    break-if color-found?
-    color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 7/white
-  }
-  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+    <span class="muControl">break-if</span> color-found?
+    color<span class="Special"> &lt;- </span>copy <span class="Constant">7/white</span>
+  <span class="Delimiter">}</span>
+  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default bg-color to black</span>
-    break-if bg-color-found?
-    bg-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0/black
-  }
-  trace 90, [<span class="Identifier">print</span>-character], c
-  {
+    <span class="muControl">break-if</span> bg-color-found?
+    bg-color<span class="Special"> &lt;- </span>copy <span class="Constant">0/black</span>
+  <span class="Delimiter">}</span>
+  trace <span class="Constant">90</span>, <span class="Constant">[print-character]</span>, c
+  <span class="Delimiter">{</span>
     <span class="Comment"># if x exists</span>
     <span class="Comment"># (handle special cases exactly like in the real screen)</span>
-    break-unless sc
-    width:number<span class="Special"> &lt;- </span>get *sc, num-columns:offset
-    height:number<span class="Special"> &lt;- </span>get *sc, num-rows:offset
+    <span class="muControl">break-unless</span> sc
+    width:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-columns:offset</span>
+    height:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-rows:offset</span>
     <span class="Comment"># if cursor is out of bounds, silently exit</span>
-    row:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-row:offset
-    legal?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, 0
-    reply-unless legal?, sc
+    row:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-row:offset</span>
+    legal?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, <span class="Constant">0</span>
+    <span class="muControl">reply-unless</span> legal?, sc
     legal?<span class="Special"> &lt;- </span>lesser-than *row, height
-    reply-unless legal?, sc
-    column:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-    legal?<span class="Special"> &lt;- </span>greater-or-equal *column, 0
-    reply-unless legal?, sc
+    <span class="muControl">reply-unless</span> legal?, sc
+    column:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+    legal?<span class="Special"> &lt;- </span>greater-or-equal *column, <span class="Constant">0</span>
+    <span class="muControl">reply-unless</span> legal?, sc
     legal?<span class="Special"> &lt;- </span>lesser-than *column, width
-    reply-unless legal?, sc
+    <span class="muControl">reply-unless</span> legal?, sc
     <span class="Comment"># special-case: newline</span>
-    {
-      newline?:boolean<span class="Special"> &lt;- </span>equal c, 10/newline
-      break-unless newline?
-      {
+    <span class="Delimiter">{</span>
+      newline?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">10/newline</span>
+      <span class="muControl">break-unless</span> newline?
+      <span class="Delimiter">{</span>
         <span class="Comment"># unless cursor is already at bottom</span>
-        bottom:number<span class="Special"> &lt;- </span>subtract height, 1
+        bottom:number<span class="Special"> &lt;- </span>subtract height, <span class="Constant">1</span>
         at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, bottom
-        break-if at-bottom?
+        <span class="muControl">break-if</span> at-bottom?
         <span class="Comment"># move it to the next row</span>
-        *column<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-        *row<span class="Special"> &lt;- </span>add *row, 1
-      }
-      reply sc/same-as-ingredient:0
-    }
+        *column<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+        *row<span class="Special"> &lt;- </span>add *row, <span class="Constant">1</span>
+      <span class="Delimiter">}</span>
+      <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+    <span class="Delimiter">}</span>
     <span class="Comment"># save character in fake screen</span>
     index:number<span class="Special"> &lt;- </span>multiply *row, width
     index<span class="Special"> &lt;- </span>add index, *column
-    buf:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *sc, data:offset
-    len:number<span class="Special"> &lt;- </span><span class="Identifier">length</span> *buf
+    buf:address:array:screen-cell<span class="Special"> &lt;- </span>get *sc, <span class="Constant">data:offset</span>
+    len:number<span class="Special"> &lt;- </span>length *buf
     <span class="Comment"># special-case: backspace</span>
-    {
-      backspace?:boolean<span class="Special"> &lt;- </span>equal c, 8
-      break-unless backspace?
-      {
+    <span class="Delimiter">{</span>
+      backspace?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">8</span>
+      <span class="muControl">break-unless</span> backspace?
+      <span class="Delimiter">{</span>
         <span class="Comment"># unless cursor is already at left margin</span>
-        at-left?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *column, 0
-        break-if at-left?
+        at-left?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *column, <span class="Constant">0</span>
+        <span class="muControl">break-if</span> at-left?
         <span class="Comment"># clear previous location</span>
-        *column<span class="Special"> &lt;- </span>subtract *column, 1
-        index<span class="Special"> &lt;- </span>subtract index, 1
+        *column<span class="Special"> &lt;- </span>subtract *column, <span class="Constant">1</span>
+        index<span class="Special"> &lt;- </span>subtract index, <span class="Constant">1</span>
         cursor:address:screen-cell<span class="Special"> &lt;- </span>index-address *buf, index
-        cursor-contents:address:character<span class="Special"> &lt;- </span>get-address *cursor, contents:offset
-        *cursor-contents<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 32/space
-        cursor-color:address:number<span class="Special"> &lt;- </span>get-address *cursor, color:offset
-        *cursor-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 7/white
-      }
-      reply sc/same-as-ingredient:0
-    }
+        cursor-contents:address:character<span class="Special"> &lt;- </span>get-address *cursor, <span class="Constant">contents:offset</span>
+        *cursor-contents<span class="Special"> &lt;- </span>copy <span class="Constant">32/space</span>
+        cursor-color:address:number<span class="Special"> &lt;- </span>get-address *cursor, <span class="Constant">color:offset</span>
+        *cursor-color<span class="Special"> &lt;- </span>copy <span class="Constant">7/white</span>
+      <span class="Delimiter">}</span>
+      <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+    <span class="Delimiter">}</span>
     cursor:address:screen-cell<span class="Special"> &lt;- </span>index-address *buf, index
-    cursor-contents:address:character<span class="Special"> &lt;- </span>get-address *cursor, contents:offset
-    *cursor-contents<span class="Special"> &lt;- </span><span class="Identifier">copy</span> c
-    cursor-color:address:number<span class="Special"> &lt;- </span>get-address *cursor, color:offset
-    *cursor-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> color
+    cursor-contents:address:character<span class="Special"> &lt;- </span>get-address *cursor, <span class="Constant">contents:offset</span>
+    *cursor-contents<span class="Special"> &lt;- </span>copy c
+    cursor-color:address:number<span class="Special"> &lt;- </span>get-address *cursor, <span class="Constant">color:offset</span>
+    *cursor-color<span class="Special"> &lt;- </span>copy color
     <span class="Comment"># increment column unless it's already all the way to the right</span>
-    {
-      right:number<span class="Special"> &lt;- </span>subtract width, 1
+    <span class="Delimiter">{</span>
+      right:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">1</span>
       at-right?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, right
-      break-if at-right?
-      *column<span class="Special"> &lt;- </span>add *column, 1
-    }
-    reply sc/same-as-ingredient:0
-  }
+      <span class="muControl">break-if</span> at-right?
+      *column<span class="Special"> &lt;- </span>add *column, <span class="Constant">1</span>
+    <span class="Delimiter">}</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
-  <span class="Identifier">print</span>-character-to-display c, color, bg-color
-  reply sc/same-as-ingredient:0
+  print-character-to-display c, color, bg-color
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-scenario <span class="Identifier">print</span>-character-at-top-left [
+<span class="muScenario">scenario</span> print-character-at-top-left [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    2:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    3:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *2:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">2</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">3</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">2</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    3<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    4<span class="Special"> &lt;- </span>97  <span class="Comment"># 'a'</span>
-    5<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    6<span class="Special"> &lt;- </span>0
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-character-color [
+<span class="muScenario">scenario</span> print-character-color [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97/a, 1/red
-    2:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    3:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *2:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97/a</span>, <span class="Constant">1/red</span>
+    <span class="Constant">2</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">3</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">2</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    3<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    4<span class="Special"> &lt;- </span>97  <span class="Comment"># 'a'</span>
-    5<span class="Special"> &lt;- </span>1  <span class="Comment"># red</span>
-    6<span class="Special"> &lt;- </span>0
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># red</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-backspace-character [
+<span class="muScenario">scenario</span> print-backspace-character [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 8  <span class="Comment"># backspace</span>
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
-    3:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    4:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *3:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">8</span>  <span class="Comment"># backspace</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
+    <span class="Constant">3</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">4</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>0  <span class="Comment"># cursor column</span>
-    4<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    5<span class="Special"> &lt;- </span>32  <span class="Comment"># space, not 'a'</span>
-    6<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    7<span class="Special"> &lt;- </span>0
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># cursor column</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">32</span>  <span class="Comment"># space, not 'a'</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-extra-backspace-character [
+<span class="muScenario">scenario</span> print-extra-backspace-character [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 8  <span class="Comment"># backspace</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 8  <span class="Comment"># backspace</span>
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
-    3:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    4:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *3:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">8</span>  <span class="Comment"># backspace</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">8</span>  <span class="Comment"># backspace</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
+    <span class="Constant">3</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">4</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>0  <span class="Comment"># cursor column</span>
-    4<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    5<span class="Special"> &lt;- </span>32  <span class="Comment"># space, not 'a'</span>
-    6<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    7<span class="Special"> &lt;- </span>0
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># cursor column</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">32</span>  <span class="Comment"># space, not 'a'</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-at-right-margin [
+<span class="muScenario">scenario</span> print-at-right-margin [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 2/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 98  <span class="Comment"># 'b'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 99  <span class="Comment"># 'c'</span>
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
-    3:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    4:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *3:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">2/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">98</span>  <span class="Comment"># 'b'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">99</span>  <span class="Comment"># 'c'</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
+    <span class="Constant">3</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">4</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>1  <span class="Comment"># cursor column</span>
-    4<span class="Special"> &lt;- </span>4  <span class="Comment"># width*height</span>
-    5<span class="Special"> &lt;- </span>97  <span class="Comment"># 'a'</span>
-    6<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    7<span class="Special"> &lt;- </span>99  <span class="Comment"># 'c' over 'b'</span>
-    8<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    9<span class="Special"> &lt;- </span>0
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># cursor column</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">99</span>  <span class="Comment"># 'c' over 'b'</span>
+    <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">9</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-newline-character [
+<span class="muScenario">scenario</span> print-newline-character [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-row:offset
-    3:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
-    4:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    5:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *4:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-row:offset</span>
+    <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
+    <span class="Constant">4</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">5</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">4</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>1  <span class="Comment"># cursor row</span>
-    3<span class="Special"> &lt;- </span>0  <span class="Comment"># cursor column</span>
-    5<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    6<span class="Special"> &lt;- </span>97  <span class="Comment"># 'a'</span>
-    7<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    8<span class="Special"> &lt;- </span>0
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># cursor row</span>
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># cursor column</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-newline-at-bottom-line [
+<span class="muScenario">scenario</span> print-newline-at-bottom-line [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-row:offset
-    3:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-row:offset</span>
+    <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>1  <span class="Comment"># cursor row</span>
-    3<span class="Special"> &lt;- </span>0  <span class="Comment"># cursor column</span>
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># cursor row</span>
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># cursor column</span>
   ]
 ]
 
-scenario <span class="Identifier">print</span>-at-bottom-right [
+<span class="muScenario">scenario</span> print-at-bottom-right [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 2/width, 2/height
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 98  <span class="Comment"># 'b'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 99  <span class="Comment"># 'c'</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 10/newline
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 100  <span class="Comment"># 'd'</span>
-    2:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-row:offset
-    3:number<span class="Special"> &lt;- </span>get *1:address:screen, cursor-column:offset
-    4:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    5:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *4:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">2/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">98</span>  <span class="Comment"># 'b'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">99</span>  <span class="Comment"># 'c'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">10/newline</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">100</span>  <span class="Comment"># 'd'</span>
+    <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-row:offset</span>
+    <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">cursor-column:offset</span>
+    <span class="Constant">4</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">5</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">4</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    2<span class="Special"> &lt;- </span>1  <span class="Comment"># cursor row</span>
-    3<span class="Special"> &lt;- </span>1  <span class="Comment"># cursor column</span>
-    5<span class="Special"> &lt;- </span>4  <span class="Comment"># width*height</span>
-    6<span class="Special"> &lt;- </span>0  <span class="Comment"># unused</span>
-    7<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    8<span class="Special"> &lt;- </span>0  <span class="Comment"># unused</span>
-    9<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    10<span class="Special"> &lt;- </span>97 <span class="Comment"># 'a'</span>
-    11<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    12<span class="Special"> &lt;- </span>100  <span class="Comment"># 'd' over 'b' and 'c' and newline</span>
-    13<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    14<span class="Special"> &lt;- </span>0
+    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># cursor row</span>
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># cursor column</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># unused</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># unused</span>
+    <span class="Constant">9</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">97</span> <span class="Comment"># 'a'</span>
+    <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">12</span><span class="Special"> &lt;- </span><span class="Constant">100</span>  <span class="Comment"># 'd' over 'b' and 'c' and newline</span>
+    <span class="Constant">13</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">14</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
-recipe clear-line [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> clear-line [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, clear line in fake screen</span>
-  {
-    break-unless sc
-    width:number<span class="Special"> &lt;- </span>get *sc, num-columns:offset
-    column:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-    original-column:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *column
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    width:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-columns:offset</span>
+    column:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+    original-column:number<span class="Special"> &lt;- </span>copy *column
     <span class="Comment"># space over the entire line</span>
-    {
-      right:number<span class="Special"> &lt;- </span>subtract width, 1
+    <span class="Delimiter">{</span>
+      right:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">1</span>
       done?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, right
-      break-if done?
-      <span class="Identifier">print</span>-character sc, [ ]  <span class="Comment"># implicitly updates 'column'</span>
-      loop
-    }
+      <span class="muControl">break-if</span> done?
+      print-character sc, <span class="Constant">[ ]</span>  <span class="Comment"># implicitly updates 'column'</span>
+      <span class="muControl">loop</span>
+    <span class="Delimiter">}</span>
     <span class="Comment"># now back to where the cursor was</span>
-    *column<span class="Special"> &lt;- </span><span class="Identifier">copy</span> original-column
-    reply sc/same-as-ingredient:0
-  }
+    *column<span class="Special"> &lt;- </span>copy original-column
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   clear-line-on-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-position [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-position [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, lookup cursor in fake screen</span>
-  {
-    break-unless sc
-    row:number<span class="Special"> &lt;- </span>get *sc, cursor-row:offset
-    column:number<span class="Special"> &lt;- </span>get *sc, cursor-column:offset
-    reply row, column, sc/same-as-ingredient:0
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    row:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">cursor-row:offset</span>
+    column:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">cursor-column:offset</span>
+    <span class="muControl">reply</span> row, column, sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   row, column<span class="Special"> &lt;- </span>cursor-position-on-display
-  reply row, column, sc/same-as-ingredient:0
+  <span class="muControl">reply</span> row, column, sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe move-cursor [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
-  <span class="Identifier">new</span>-row:number<span class="Special"> &lt;- </span>next-ingredient
-  <span class="Identifier">new</span>-column:number<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> move-cursor [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  new-row:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  new-column:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    row:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-row:offset
-    *row<span class="Special"> &lt;- </span><span class="Identifier">copy</span> <span class="Identifier">new</span>-row
-    column:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-    *column<span class="Special"> &lt;- </span><span class="Identifier">copy</span> <span class="Identifier">new</span>-column
-    reply sc/same-as-ingredient:0
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    row:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-row:offset</span>
+    *row<span class="Special"> &lt;- </span>copy new-row
+    column:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+    *column<span class="Special"> &lt;- </span>copy new-column
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
-  move-cursor-on-display <span class="Identifier">new</span>-row, <span class="Identifier">new</span>-column
-  reply sc/same-as-ingredient:0
+  move-cursor-on-display new-row, new-column
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-scenario clear-line-erases-printed-characters [
+<span class="muScenario">scenario</span> clear-line-erases-printed-characters [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
     <span class="Comment"># print a character</span>
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-character 1:address:screen, 97  <span class="Comment"># 'a'</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-character <span class="Constant">1</span>:address:screen, <span class="Constant">97</span>  <span class="Comment"># 'a'</span>
     <span class="Comment"># move cursor to start of line</span>
-    1:address:screen<span class="Special"> &lt;- </span>move-cursor 1:address:screen, 0/row, 0/column
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>move-cursor <span class="Constant">1</span>:address:screen, <span class="Constant">0/row</span>, <span class="Constant">0/column</span>
     <span class="Comment"># clear line</span>
-    1:address:screen<span class="Special"> &lt;- </span>clear-line 1:address:screen
-    2:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    3:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *2:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>clear-line <span class="Constant">1</span>:address:screen
+    <span class="Constant">2</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">3</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">2</span>:address:array:screen-cell
   ]
   <span class="Comment"># screen should be blank</span>
   memory-should-contain [
-    3<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    4<span class="Special"> &lt;- </span>0
-    5<span class="Special"> &lt;- </span>7
-    6<span class="Special"> &lt;- </span>0
-    7<span class="Special"> &lt;- </span>7
-    8<span class="Special"> &lt;- </span>0
-    9<span class="Special"> &lt;- </span>7
-    10<span class="Special"> &lt;- </span>0
-    11<span class="Special"> &lt;- </span>7
-    12<span class="Special"> &lt;- </span>0
-    13<span class="Special"> &lt;- </span>7
-    14<span class="Special"> &lt;- </span>0
-    15<span class="Special"> &lt;- </span>7
+    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">7</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">7</span>
+    <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">9</span><span class="Special"> &lt;- </span><span class="Constant">7</span>
+    <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">7</span>
+    <span class="Constant">12</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">13</span><span class="Special"> &lt;- </span><span class="Constant">7</span>
+    <span class="Constant">14</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">15</span><span class="Special"> &lt;- </span><span class="Constant">7</span>
   ]
 ]
 
-recipe cursor-down [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-down [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    {
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    <span class="Delimiter">{</span>
       <span class="Comment"># increment row unless it's already all the way down</span>
-      height:number<span class="Special"> &lt;- </span>get *sc, num-rows:offset
-      row:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-row:offset
-      <span class="Identifier">max</span>:number<span class="Special"> &lt;- </span>subtract height, 1
-      at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, <span class="Identifier">max</span>
-      break-if at-bottom?
-      *row<span class="Special"> &lt;- </span>add *row, 1
-    }
-    reply sc/same-as-ingredient:0
-  }
+      height:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-rows:offset</span>
+      row:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-row:offset</span>
+      max:number<span class="Special"> &lt;- </span>subtract height, <span class="Constant">1</span>
+      at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, max
+      <span class="muControl">break-if</span> at-bottom?
+      *row<span class="Special"> &lt;- </span>add *row, <span class="Constant">1</span>
+    <span class="Delimiter">}</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-down-on-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-up [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-up [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    {
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    <span class="Delimiter">{</span>
       <span class="Comment"># decrement row unless it's already all the way up</span>
-      row:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-row:offset
-      at-top?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *row, 0
-      break-if at-top?
-      *row<span class="Special"> &lt;- </span>subtract *row, 1
-    }
-    reply sc/same-as-ingredient:0
-  }
+      row:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-row:offset</span>
+      at-top?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *row, <span class="Constant">0</span>
+      <span class="muControl">break-if</span> at-top?
+      *row<span class="Special"> &lt;- </span>subtract *row, <span class="Constant">1</span>
+    <span class="Delimiter">}</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-up-on-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-right [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-right [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    {
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    <span class="Delimiter">{</span>
       <span class="Comment"># increment column unless it's already all the way to the right</span>
-      width:number<span class="Special"> &lt;- </span>get *sc, num-columns:offset
-      column:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-      <span class="Identifier">max</span>:number<span class="Special"> &lt;- </span>subtract width, 1
-      at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, <span class="Identifier">max</span>
-      break-if at-bottom?
-      *column<span class="Special"> &lt;- </span>add *column, 1
-    }
-    reply sc/same-as-ingredient:0
-  }
+      width:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-columns:offset</span>
+      column:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+      max:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">1</span>
+      at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, max
+      <span class="muControl">break-if</span> at-bottom?
+      *column<span class="Special"> &lt;- </span>add *column, <span class="Constant">1</span>
+    <span class="Delimiter">}</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-right-on-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-left [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-left [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    {
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    <span class="Delimiter">{</span>
       <span class="Comment"># decrement column unless it's already all the way to the left</span>
-      column:address:number<span class="Special"> &lt;- </span>get-address *sc, cursor-column:offset
-      at-top?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *column, 0
-      break-if at-top?
-      *column<span class="Special"> &lt;- </span>subtract *column, 1
-    }
-    reply sc/same-as-ingredient:0
-  }
+      column:address:number<span class="Special"> &lt;- </span>get-address *sc, <span class="Constant">cursor-column:offset</span>
+      at-top?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *column, <span class="Constant">0</span>
+      <span class="muControl">break-if</span> at-top?
+      *column<span class="Special"> &lt;- </span>subtract *column, <span class="Constant">1</span>
+    <span class="Delimiter">}</span>
+    <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-left-on-display
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-to-start-of-line [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-to-start-of-line [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   row:number, _, sc<span class="Special"> &lt;- </span>cursor-position sc
-  column:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
+  column:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
   sc<span class="Special"> &lt;- </span>move-cursor sc, row, column
-  reply sc/same-as-ingredient:0
+  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe cursor-to-next-line [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> cursor-to-next-line [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen<span class="Special"> &lt;- </span>cursor-down screen
   screen<span class="Special"> &lt;- </span>cursor-to-start-of-line screen
-  reply screen/same-as-ingredient:0
+  <span class="muControl">reply</span> screen/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-recipe screen-width [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> screen-width [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    width:number<span class="Special"> &lt;- </span>get *sc, num-columns:offset
-    reply width
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    width:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-columns:offset</span>
+    <span class="muControl">reply</span> width
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   width:number<span class="Special"> &lt;- </span>display-width
-  reply width
+  <span class="muControl">reply</span> width
 ]
 
-recipe screen-height [
-  <span class="Underlined">local</span>-scope
-  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> screen-height [
+  <span class="Constant">local-scope</span>
+  sc:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  {
-    break-unless sc
-    height:number<span class="Special"> &lt;- </span>get *sc, num-rows:offset
-    reply height
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> sc
+    height:number<span class="Special"> &lt;- </span>get *sc, <span class="Constant">num-rows:offset</span>
+    <span class="muControl">reply</span> height
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   height:number<span class="Special"> &lt;- </span>display-height
-  reply height
+  <span class="muControl">reply</span> height
 ]
 
-recipe hide-cursor [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> hide-cursor [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
-  {
-    break-unless screen
-    reply screen
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> screen
+    <span class="muControl">reply</span> screen
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   hide-cursor-on-display
-  reply screen
+  <span class="muControl">reply</span> screen
 ]
 
-recipe show-cursor [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> show-cursor [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
-  {
-    break-unless screen
-    reply screen
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> screen
+    <span class="muControl">reply</span> screen
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   show-cursor-on-display
-  reply screen
+  <span class="muControl">reply</span> screen
 ]
 
-recipe hide-screen [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> hide-screen [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Comment"># todo: help test this</span>
-  {
-    break-unless screen
-    reply screen
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> screen
+    <span class="muControl">reply</span> screen
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   hide-display
-  reply screen
+  <span class="muControl">reply</span> screen
 ]
 
-recipe show-screen [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
+<span class="muRecipe">recipe</span> show-screen [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Comment"># todo: help test this</span>
-  {
-    break-unless screen
-    reply screen
-  }
+  <span class="Delimiter">{</span>
+    <span class="muControl">break-unless</span> screen
+    <span class="muControl">reply</span> screen
+  <span class="Delimiter">}</span>
   <span class="Comment"># otherwise, real screen</span>
   show-display
-  reply screen
+  <span class="muControl">reply</span> screen
 ]
 
-recipe <span class="Identifier">print</span>-string [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
-  s:address:<span class="Identifier">array</span>:character<span class="Special"> &lt;- </span>next-ingredient
-  color:number, color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+<span class="muRecipe">recipe</span> print-string [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default color to white</span>
-    break-if color-found?
-    color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 7/white
-  }
-  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+    <span class="muControl">break-if</span> color-found?
+    color<span class="Special"> &lt;- </span>copy <span class="Constant">7/white</span>
+  <span class="Delimiter">}</span>
+  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default bg-color to black</span>
-    break-if bg-color-found?
-    bg-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0/black
-  }
-  len:number<span class="Special"> &lt;- </span><span class="Identifier">length</span> *s
-  i:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
-  {
+    <span class="muControl">break-if</span> bg-color-found?
+    bg-color<span class="Special"> &lt;- </span>copy <span class="Constant">0/black</span>
+  <span class="Delimiter">}</span>
+  len:number<span class="Special"> &lt;- </span>length *s
+  i:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+  <span class="Delimiter">{</span>
     done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, len
-    break-if done?
+    <span class="muControl">break-if</span> done?
     c:character<span class="Special"> &lt;- </span>index *s, i
-    <span class="Identifier">print</span>-character screen, c, color, bg-color
-    i<span class="Special"> &lt;- </span>add i, 1
-    loop
-  }
-  reply screen/same-as-ingredient:0
+    print-character screen, c, color, bg-color
+    i<span class="Special"> &lt;- </span>add i, <span class="Constant">1</span>
+    <span class="muControl">loop</span>
+  <span class="Delimiter">}</span>
+  <span class="muControl">reply</span> screen/same-as-ingredient:<span class="Constant">0</span>
 ]
 
-scenario <span class="Identifier">print</span>-string-stops-at-right-margin [
+<span class="muScenario">scenario</span> print-string-stops-at-right-margin [
   run [
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
-    2:address:<span class="Identifier">array</span>:character<span class="Special"> &lt;- </span><span class="Identifier">new</span> [abcd]
-    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">print</span>-string 1:address:screen, 2:address:<span class="Identifier">array</span>:character
-    3:address:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span>get *1:address:screen, data:offset
-    4:<span class="Identifier">array</span>:screen-cell<span class="Special"> &lt;- </span><span class="Identifier">copy</span> *3:address:<span class="Identifier">array</span>:screen-cell
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>new-fake-screen <span class="Constant">3/width</span>, <span class="Constant">2/height</span>
+    <span class="Constant">2</span>:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
+    <span class="Constant">1</span>:address:screen<span class="Special"> &lt;- </span>print-string <span class="Constant">1</span>:address:screen, <span class="Constant">2</span>:address:array:character
+    <span class="Constant">3</span>:address:array:screen-cell<span class="Special"> &lt;- </span>get *<span class="Constant">1</span>:address:screen, <span class="Constant">data:offset</span>
+    <span class="Constant">4</span>:array:screen-cell<span class="Special"> &lt;- </span>copy *<span class="Constant">3</span>:address:array:screen-cell
   ]
   memory-should-contain [
-    4<span class="Special"> &lt;- </span>6  <span class="Comment"># width*height</span>
-    5<span class="Special"> &lt;- </span>97  <span class="Comment"># 'a'</span>
-    6<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    7<span class="Special"> &lt;- </span>98  <span class="Comment"># 'b'</span>
-    8<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    9<span class="Special"> &lt;- </span>100  <span class="Comment"># 'd' overwrites 'c'</span>
-    10<span class="Special"> &lt;- </span>7  <span class="Comment"># white</span>
-    11<span class="Special"> &lt;- </span>0  <span class="Comment"># unused</span>
+    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">6</span>  <span class="Comment"># width*height</span>
+    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># 'a'</span>
+    <span class="Constant">6</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">7</span><span class="Special"> &lt;- </span><span class="Constant">98</span>  <span class="Comment"># 'b'</span>
+    <span class="Constant">8</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">9</span><span class="Special"> &lt;- </span><span class="Constant">100</span>  <span class="Comment"># 'd' overwrites 'c'</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">7</span>  <span class="Comment"># white</span>
+    <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># unused</span>
   ]
 ]
 
-recipe <span class="Identifier">print</span>-integer [
-  <span class="Underlined">local</span>-scope
-  screen:address<span class="Special"> &lt;- </span>next-ingredient
-  n:number<span class="Special"> &lt;- </span>next-ingredient
-  color:number, color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+<span class="muRecipe">recipe</span> print-integer [
+  <span class="Constant">local-scope</span>
+  screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  n:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default color to white</span>
-    break-if color-found?
-    color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 7/white
-  }
-  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span>next-ingredient
-  {
+    <span class="muControl">break-if</span> color-found?
+    color<span class="Special"> &lt;- </span>copy <span class="Constant">7/white</span>
+  <span class="Delimiter">}</span>
+  bg-color:number, bg-color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
+  <span class="Delimiter">{</span>
     <span class="Comment"># default bg-color to black</span>
-    break-if bg-color-found?
-    bg-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0/black
-  }
+    <span class="muControl">break-if</span> bg-color-found?
+    bg-color<span class="Special"> &lt;- </span>copy <span class="Constant">0/black</span>
+  <span class="Delimiter">}</span>
   <span class="Comment"># todo: other bases besides decimal</span>
-  s:address:<span class="Identifier">array</span>:character<span class="Special"> &lt;- </span>integer-to-decimal-string n
-  <span class="Identifier">print</span>-string screen, s, color, bg-color
-  reply screen/same-as-ingredient:0
+  s:address:array:character<span class="Special"> &lt;- </span>integer-to-decimal-string n
+  print-string screen, s, color, bg-color
+  <span class="muControl">reply</span> screen/same-as-ingredient:<span class="Constant">0</span>
 ]
 </pre>
 </body>