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-06 16:35:46 -0700
committerKartik K. Agaram <vc@akkartik.com>2015-09-06 16:35:46 -0700
commit0e4a335edc7d4e584924fd6b298156e45d2626c8 (patch)
tree4bde00176d6d00b72462e856974fecd4411ef025 /html/071print.mu.html
parent3cf4cc43f2622816777c22c49c32e5159574a1d3 (diff)
downloadmu-0e4a335edc7d4e584924fd6b298156e45d2626c8.tar.gz
2175
Diffstat (limited to 'html/071print.mu.html')
-rw-r--r--html/071print.mu.html960
1 files changed, 479 insertions, 481 deletions
diff --git a/html/071print.mu.html b/html/071print.mu.html
index 4da9db86..ce70d068 100644
--- a/html/071print.mu.html
+++ b/html/071print.mu.html
@@ -13,14 +13,10 @@
 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; }
-.muRecipe { color: #ff8700; }
-.muScenario { color: #00af00; }
-.Comment { color: #9090ff; }
-.Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
-.Delimiter { color: #a04060; }
-.muControl { color: #c0a020; }
+.Comment { color: #9090ff; }
+.Underlined { color: #c000c0; text-decoration: underline; }
+.Identifier { color: #804000; }
 -->
 </style>
 
@@ -40,7 +36,7 @@ container screen [
   num-columns:number
   cursor-row:number
   cursor-column:number
-  data:address:array:screen-cell
+  data:address:<span class="Identifier">array</span>:screen-cell
 ]
 
 container screen-cell [
@@ -48,671 +44,673 @@ container screen-cell [
   color:number
 ]
 
-<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>
+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
   bufsize:number<span class="Special"> &lt;- </span>multiply *width, *height
-  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
+  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
   clear-screen result
-  <span class="muControl">reply</span> result
+  reply result
 ]
 
-<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>
+recipe clear-screen [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> sc
+  {
+    break-unless sc
     <span class="Comment"># clear fake screen</span>
-    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?
+    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?
       curr:address:screen-cell<span class="Special"> &lt;- </span>index-address *buf, i
-      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>
+      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
+    }
     <span class="Comment"># reset cursor</span>
-    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>
+    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
+  }
   <span class="Comment"># otherwise, real screen</span>
   clear-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
-]
-
-<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>
+  reply sc/same-as-ingredient:0
+]
+
+recipe sync-screen [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
+  {
+    break-if sc
+    sync-display
+  }
+  <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
+  {
     done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, len
-    <span class="muControl">break-if</span> done?
+    break-if done?
     curr:screen-cell<span class="Special"> &lt;- </span>index *buf, i
-    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
+    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
     <span class="Comment"># not 0</span>
-    <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>
+    reply 0/false
+  }
+  reply 1/true
 ]
 
-<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>
+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="Comment"># default color to white</span>
-    <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>
+    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="Comment"># default bg-color to black</span>
-    <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>
+    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="Comment"># if x exists</span>
     <span class="Comment"># (handle special cases exactly like in the real screen)</span>
-    <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>
+    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="Comment"># if cursor is out of bounds, silently exit</span>
-    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
+    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
     legal?<span class="Special"> &lt;- </span>lesser-than *row, height
-    <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
+    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
     legal?<span class="Special"> &lt;- </span>lesser-than *column, width
-    <span class="muControl">reply-unless</span> legal?, sc
+    reply-unless legal?, sc
     <span class="Comment"># special-case: newline</span>
-    <span class="Delimiter">{</span>
-      newline?:boolean<span class="Special"> &lt;- </span>equal c, <span class="Constant">10/newline</span>
-<span class="CommentedCode">#?       $print c, [ ], newline?, 10/newline</span>
-      <span class="muControl">break-unless</span> newline?
-      <span class="Delimiter">{</span>
+    {
+      newline?:boolean<span class="Special"> &lt;- </span>equal c, 10/newline
+      break-unless newline?
+      {
         <span class="Comment"># unless cursor is already at bottom</span>
-        bottom:number<span class="Special"> &lt;- </span>subtract height, <span class="Constant">1</span>
+        bottom:number<span class="Special"> &lt;- </span>subtract height, 1
         at-bottom?:boolean<span class="Special"> &lt;- </span>greater-or-equal *row, bottom
-        <span class="muControl">break-if</span> at-bottom?
+        break-if at-bottom?
         <span class="Comment"># move it to the next row</span>
-        *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>
+        *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
+    }
     <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: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
+    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
     <span class="Comment"># special-case: backspace</span>
-    <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>
+    {
+      backspace?:boolean<span class="Special"> &lt;- </span>equal c, 8
+      break-unless backspace?
+      {
         <span class="Comment"># unless cursor is already at left margin</span>
-        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?
+        at-left?:boolean<span class="Special"> &lt;- </span>lesser-or-equal *column, 0
+        break-if at-left?
         <span class="Comment"># clear previous location</span>
-        *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>
+        *column<span class="Special"> &lt;- </span>subtract *column, 1
+        index<span class="Special"> &lt;- </span>subtract index, 1
         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, <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>
-<span class="CommentedCode">#?     $print [saving character ], c, [ to fake screen ], cursor, 10/newline</span>
+        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:address:screen-cell<span class="Special"> &lt;- </span>index-address *buf, index
-    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
+    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
     <span class="Comment"># increment column unless it's already all the way to the right</span>
-    <span class="Delimiter">{</span>
-      right:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">1</span>
+    {
+      right:number<span class="Special"> &lt;- </span>subtract width, 1
       at-right?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, right
-      <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>
+      break-if at-right?
+      *column<span class="Special"> &lt;- </span>add *column, 1
+    }
+    reply sc/same-as-ingredient:0
+  }
   <span class="Comment"># otherwise, real screen</span>
-  print-character-to-display c, color, bg-color
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  <span class="Identifier">print</span>-character-to-display c, color, bg-color
+  reply sc/same-as-ingredient:0
 ]
 
-<span class="muScenario">scenario</span> print-character-at-top-left [
+scenario <span class="Identifier">print</span>-character-at-top-left [
   run [
-<span class="CommentedCode">#?     $start-tracing #? 3</span>
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-character-color [
+scenario <span class="Identifier">print</span>-character-color [
   run [
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-backspace-character [
+scenario <span class="Identifier">print</span>-backspace-character [
   run [
-<span class="CommentedCode">#?     $start-tracing #? 3</span>
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-extra-backspace-character [
+scenario <span class="Identifier">print</span>-extra-backspace-character [
   run [
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-at-right-margin [
+scenario <span class="Identifier">print</span>-at-right-margin [
   run [
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-newline-character [
+scenario <span class="Identifier">print</span>-newline-character [
   run [
-<span class="CommentedCode">#?     $start-tracing #? 3</span>
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-newline-at-bottom-line [
+scenario <span class="Identifier">print</span>-newline-at-bottom-line [
   run [
-    <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>
+    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
   ]
   memory-should-contain [
-    <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>
+    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="muScenario">scenario</span> print-at-bottom-right [
+scenario <span class="Identifier">print</span>-at-bottom-right [
   run [
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="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>
+recipe clear-line [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, clear line in fake screen</span>
-  <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
+  {
+    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="Comment"># space over the entire line</span>
-<span class="CommentedCode">#?     $start-tracing #? 1</span>
-    <span class="Delimiter">{</span>
-<span class="CommentedCode">#?       $print *column, 10/newline</span>
-      right:number<span class="Special"> &lt;- </span>subtract width, <span class="Constant">1</span>
+    {
+      right:number<span class="Special"> &lt;- </span>subtract width, 1
       done?:boolean<span class="Special"> &lt;- </span>greater-or-equal *column, right
-      <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>
+      break-if done?
+      <span class="Identifier">print</span>-character sc, [ ]  <span class="Comment"># implicitly updates 'column'</span>
+      loop
+    }
     <span class="Comment"># now back to where the cursor was</span>
-    *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>
+    *column<span class="Special"> &lt;- </span><span class="Identifier">copy</span> original-column
+    reply sc/same-as-ingredient:0
+  }
   <span class="Comment"># otherwise, real screen</span>
   clear-line-on-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-position [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, lookup cursor in fake screen</span>
-  <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>
+  {
+    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
+  }
   row, column<span class="Special"> &lt;- </span>cursor-position-on-display
-  <span class="muControl">reply</span> row, column, sc/same-as-ingredient:<span class="Constant">0</span>
+  reply row, column, sc/same-as-ingredient:0
 ]
 
-<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>
+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="Comment"># if x exists, move cursor in fake screen</span>
-  <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>
+  {
+    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="Comment"># otherwise, real screen</span>
-  move-cursor-on-display new-row, new-column
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  move-cursor-on-display <span class="Identifier">new</span>-row, <span class="Identifier">new</span>-column
+  reply sc/same-as-ingredient:0
 ]
 
-<span class="muScenario">scenario</span> clear-line-erases-printed-characters [
+scenario clear-line-erases-printed-characters [
   run [
-<span class="CommentedCode">#?     $start-tracing #? 4</span>
-    <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>
+    1:address:screen<span class="Special"> &lt;- </span><span class="Identifier">new</span>-fake-screen 3/width, 2/height
     <span class="Comment"># print a character</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>
+    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="Comment"># move cursor to start of line</span>
-    <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>
+    1:address:screen<span class="Special"> &lt;- </span>move-cursor 1:address:screen, 0/row, 0/column
     <span class="Comment"># clear line</span>
-    <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
+    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="Comment"># screen should be blank</span>
   memory-should-contain [
-    <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>
+    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="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>
+recipe cursor-down [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> sc
-    <span class="Delimiter">{</span>
+  {
+    break-unless sc
+    {
       <span class="Comment"># increment row unless it's already all the way down</span>
-      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>
+      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
+  }
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-down-on-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-up [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> sc
-    <span class="Delimiter">{</span>
+  {
+    break-unless sc
+    {
       <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, <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>
+      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
+  }
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-up-on-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-right [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> sc
-    <span class="Delimiter">{</span>
+  {
+    break-unless sc
+    {
       <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, <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>
+      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
+  }
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-right-on-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-left [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> sc
-    <span class="Delimiter">{</span>
+  {
+    break-unless sc
+    {
       <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, <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>
+      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
+  }
   <span class="Comment"># otherwise, real screen</span>
   move-cursor-left-on-display
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-to-start-of-line [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   row:number, _, sc<span class="Special"> &lt;- </span>cursor-position sc
-  column:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
+  column:number<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0
   sc<span class="Special"> &lt;- </span>move-cursor sc, row, column
-  <span class="muControl">reply</span> sc/same-as-ingredient:<span class="Constant">0</span>
+  reply sc/same-as-ingredient:0
 ]
 
-<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>
+recipe cursor-to-next-line [
+  <span class="Underlined">local</span>-scope
+  screen:address<span class="Special"> &lt;- </span>next-ingredient
   screen<span class="Special"> &lt;- </span>cursor-down screen
   screen<span class="Special"> &lt;- </span>cursor-to-start-of-line screen
-  <span class="muControl">reply</span> screen/same-as-ingredient:<span class="Constant">0</span>
+  reply screen/same-as-ingredient:0
 ]
 
-<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>
+recipe screen-width [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <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>
+  {
+    break-unless sc
+    width:number<span class="Special"> &lt;- </span>get *sc, num-columns:offset
+    reply width
+  }
   <span class="Comment"># otherwise, real screen</span>
   width:number<span class="Special"> &lt;- </span>display-width
-  <span class="muControl">reply</span> width
+  reply width
 ]
 
-<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>
+recipe screen-height [
+  <span class="Underlined">local</span>-scope
+  sc:address:screen<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists, move cursor in fake screen</span>
-  <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>
+  {
+    break-unless sc
+    height:number<span class="Special"> &lt;- </span>get *sc, num-rows:offset
+    reply height
+  }
   <span class="Comment"># otherwise, real screen</span>
   height:number<span class="Special"> &lt;- </span>display-height
-  <span class="muControl">reply</span> height
+  reply height
 ]
 
-<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>
+recipe hide-cursor [
+  <span class="Underlined">local</span>-scope
+  screen:address<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists (not real display), do nothing</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> screen
-    <span class="muControl">reply</span> screen
-  <span class="Delimiter">}</span>
+  {
+    break-unless screen
+    reply screen
+  }
   <span class="Comment"># otherwise, real screen</span>
   hide-cursor-on-display
-  <span class="muControl">reply</span> screen
+  reply screen
 ]
 
-<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>
+recipe show-cursor [
+  <span class="Underlined">local</span>-scope
+  screen:address<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists (not real display), do nothing</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> screen
-    <span class="muControl">reply</span> screen
-  <span class="Delimiter">}</span>
+  {
+    break-unless screen
+    reply screen
+  }
   <span class="Comment"># otherwise, real screen</span>
   show-cursor-on-display
-  <span class="muControl">reply</span> screen
+  reply screen
 ]
 
-<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>
+recipe hide-screen [
+  <span class="Underlined">local</span>-scope
+  screen:address<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Comment"># todo: help test this</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> screen
-    <span class="muControl">reply</span> screen
-  <span class="Delimiter">}</span>
+  {
+    break-unless screen
+    reply screen
+  }
   <span class="Comment"># otherwise, real screen</span>
   hide-display
-  <span class="muControl">reply</span> screen
+  reply screen
 ]
 
-<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>
+recipe show-screen [
+  <span class="Underlined">local</span>-scope
+  screen:address<span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Comment"># todo: help test this</span>
-  <span class="Delimiter">{</span>
-    <span class="muControl">break-unless</span> screen
-    <span class="muControl">reply</span> screen
-  <span class="Delimiter">}</span>
+  {
+    break-unless screen
+    reply screen
+  }
   <span class="Comment"># otherwise, real screen</span>
   show-display
-  <span class="muControl">reply</span> screen
+  reply screen
 ]
 
-<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>
+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="Comment"># default color to white</span>
-    <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>
+    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="Comment"># default bg-color to black</span>
-    <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>
+    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
+  {
     done?:boolean<span class="Special"> &lt;- </span>greater-or-equal i, len
-    <span class="muControl">break-if</span> done?
+    break-if done?
     c:character<span class="Special"> &lt;- </span>index *s, i
-    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>
+    <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
 ]
 
-<span class="muScenario">scenario</span> print-string-stops-at-right-margin [
+scenario <span class="Identifier">print</span>-string-stops-at-right-margin [
   run [
-    <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
+    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
   ]
   memory-should-contain [
-    <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>
+    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="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>
+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="Comment"># default color to white</span>
-    <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>
+    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="Comment"># default bg-color to black</span>
-    <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>
+    break-if bg-color-found?
+    bg-color<span class="Special"> &lt;- </span><span class="Identifier">copy</span> 0/black
+  }
   <span class="Comment"># todo: other bases besides decimal</span>
-  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>
+  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
 ]
 </pre>
 </body>