3391 - type abbreviations everywhere

Well, almost. I can't use them in some places in C++ where I'm just
creating a temporary reagent without passing it through transforms. Like
in some unit tests. I can't use them in memory-should-contain.

And there's one remaining bug: I can't use abbreviations in a couple of
places in 075channel.mu.

12 files changed, 1771 insertions, 1771 deletions

diff --git a/edit/001-editor.mu b/edit/001-editor.mu
index 83bd5edf..5f6f7361 100644
--- a/edit/001-editor.mu
+++ b/edit/001-editor.mu
@@ -17,7 +17,7 @@ scenario editor-initially-prints-text-to-screen [
   assume-screen 10/width, 5/height
   run [
     1:text <- new [abc]
-    new-editor 1:text, screen:address:screen, 0/left, 10/right
+    new-editor 1:text, screen:&:screen, 0/left, 10/right
   ]
   screen-should-contain [
     # top line of screen reserved for menu
@@ -29,26 +29,26 @@ scenario editor-initially-prints-text-to-screen [
 
 container editor-data [
   # editable text: doubly linked list of characters (head contains a special sentinel)
-  data:address:duplex-list:character
-  top-of-screen:address:duplex-list:character
-  bottom-of-screen:address:duplex-list:character
+  data:&:duplex-list:char
+  top-of-screen:&:duplex-list:char
+  bottom-of-screen:&:duplex-list:char
   # location before cursor inside data
-  before-cursor:address:duplex-list:character
+  before-cursor:&:duplex-list:char
 
   # raw bounds of display area on screen
   # always displays from row 1 (leaving row 0 for a menu) and at most until bottom of screen
-  left:number
-  right:number
-  bottom:number
+  left:num
+  right:num
+  bottom:num
   # raw screen coordinates of cursor
-  cursor-row:number
-  cursor-column:number
+  cursor-row:num
+  cursor-column:num
 ]
 
 # creates a new editor widget and renders its initial appearance to screen
 #   top/left/right constrain the screen area available to the new editor
 #   right is exclusive
-def new-editor s:text, screen:address:screen, left:number, right:number -> result:address:editor-data, screen:address:screen [
+def new-editor s:text, screen:&:screen, left:num, right:num -> result:&:editor-data, screen:&:screen [
   local-scope
   load-ingredients
   # no clipping of bounds
@@ -61,7 +61,7 @@ def new-editor s:text, screen:address:screen, left:number, right:number -> resul
   *result <- put *result, cursor-row:offset, 1/top
   *result <- put *result, cursor-column:offset, left
   # initialize empty contents
-  init:address:duplex-list:character <- push 167/§, 0/tail
+  init:&:duplex-list:char <- push 167/§, 0/tail
   *result <- put *result, data:offset, init
   *result <- put *result, top-of-screen:offset, init
   *result <- put *result, before-cursor:offset, init
@@ -71,20 +71,20 @@ def new-editor s:text, screen:address:screen, left:number, right:number -> resul
   <editor-initialization>
 ]
 
-def insert-text editor:address:editor-data, text:text -> editor:address:editor-data [
+def insert-text editor:&:editor-data, text:text -> editor:&:editor-data [
   local-scope
   load-ingredients
   # early exit if text is empty
   return-unless text, editor/same-as-ingredient:0
-  len:number <- length *text
+  len:num <- length *text
   return-unless len, editor/same-as-ingredient:0
-  idx:number <- copy 0
+  idx:num <- copy 0
   # now we can start appending the rest, character by character
-  curr:address:duplex-list:character <- get *editor, data:offset
+  curr:&:duplex-list:char <- get *editor, data:offset
   {
-    done?:boolean <- greater-or-equal idx, len
+    done?:bool <- greater-or-equal idx, len
     break-if done?
-    c:character <- index *text, idx
+    c:char <- index *text, idx
     insert c, curr
     # next iter
     curr <- next curr
@@ -97,8 +97,8 @@ def insert-text editor:address:editor-data, text:text -> editor:address:editor-d
 scenario editor-initializes-without-data [
   assume-screen 5/width, 3/height
   run [
-    1:address:editor-data <- new-editor 0/data, screen:address:screen, 2/left, 5/right
-    2:editor-data <- copy *1:address:editor-data
+    1:&:editor-data <- new-editor 0/data, screen:&:screen, 2/left, 5/right
+    2:editor-data <- copy *1:&:editor-data
   ]
   memory-should-contain [
     # 2 (data) <- just the § sentinel
@@ -121,52 +121,52 @@ scenario editor-initializes-without-data [
 # Assumes cursor should be at coordinates (cursor-row, cursor-column) and
 # updates before-cursor to match. Might also move coordinates if they're
 # outside text.
-def render screen:address:screen, editor:address:editor-data -> last-row:number, last-column:number, screen:address:screen, editor:address:editor-data [
+def render screen:&:screen, editor:&:editor-data -> last-row:num, last-column:num, screen:&:screen, editor:&:editor-data [
   local-scope
   load-ingredients
   return-unless editor, 1/top, 0/left, screen/same-as-ingredient:0, editor/same-as-ingredient:1
-  left:number <- get *editor, left:offset
-  screen-height:number <- screen-height screen
-  right:number <- get *editor, right:offset
+  left:num <- get *editor, left:offset
+  screen-height:num <- screen-height screen
+  right:num <- get *editor, right:offset
   # traversing editor
-  curr:address:duplex-list:character <- get *editor, top-of-screen:offset
-  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev
+  curr:&:duplex-list:char <- get *editor, top-of-screen:offset
+  prev:&:duplex-list:char <- copy curr  # just in case curr becomes null and we can't compute prev
   curr <- next curr
   # traversing screen
   +render-loop-initialization
-  color:number <- copy 7/white
-  row:number <- copy 1/top
-  column:number <- copy left
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
+  color:num <- copy 7/white
+  row:num <- copy 1/top
+  column:num <- copy left
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
   screen <- move-cursor screen, row, column
   {
     +next-character
     break-unless curr
-    off-screen?:boolean <- greater-or-equal row, screen-height
+    off-screen?:bool <- greater-or-equal row, screen-height
     break-if off-screen?
     # update editor-data.before-cursor
     # Doing so at the start of each iteration ensures it stays one step behind
     # the current character.
     {
-      at-cursor-row?:boolean <- equal row, cursor-row
+      at-cursor-row?:bool <- equal row, cursor-row
       break-unless at-cursor-row?
-      at-cursor?:boolean <- equal column, cursor-column
+      at-cursor?:bool <- equal column, cursor-column
       break-unless at-cursor?
       before-cursor <- copy prev
     }
-    c:character <- get *curr, value:offset
+    c:char <- get *curr, value:offset
     <character-c-received>
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c, 10/newline
+      newline?:bool <- equal c, 10/newline
       break-unless newline?
       # adjust cursor if necessary
       {
-        at-cursor-row?:boolean <- equal row, cursor-row
+        at-cursor-row?:bool <- equal row, cursor-row
         break-unless at-cursor-row?
-        left-of-cursor?:boolean <- lesser-than column, cursor-column
+        left-of-cursor?:bool <- lesser-than column, cursor-column
         break-unless left-of-cursor?
         cursor-column <- copy column
         before-cursor <- prev curr
@@ -184,10 +184,10 @@ def render screen:address:screen, editor:address:editor-data -> last-row:number,
     {
       # at right? wrap. even if there's only one more letter left; we need
       # room for clicking on the cursor after it.
-      at-right?:boolean <- equal column, right
+      at-right?:bool <- equal column, right
       break-unless at-right?
       # print wrap icon
-      wrap-icon:character <- copy 8617/loop-back-to-left
+      wrap-icon:char <- copy 8617/loop-back-to-left
       print screen, wrap-icon, 245/grey
       column <- copy left
       row <- add row, 1
@@ -205,11 +205,11 @@ def render screen:address:screen, editor:address:editor-data -> last-row:number,
   *editor <- put *editor, bottom-of-screen:offset, curr
   # is cursor to the right of the last line? move to end
   {
-    at-cursor-row?:boolean <- equal row, cursor-row
-    cursor-outside-line?:boolean <- lesser-or-equal column, cursor-column
-    before-cursor-on-same-line?:boolean <- and at-cursor-row?, cursor-outside-line?
-    above-cursor-row?:boolean <- lesser-than row, cursor-row
-    before-cursor?:boolean <- or before-cursor-on-same-line?, above-cursor-row?
+    at-cursor-row?:bool <- equal row, cursor-row
+    cursor-outside-line?:bool <- lesser-or-equal column, cursor-column
+    before-cursor-on-same-line?:bool <- and at-cursor-row?, cursor-outside-line?
+    above-cursor-row?:bool <- lesser-than row, cursor-row
+    before-cursor?:bool <- or before-cursor-on-same-line?, above-cursor-row?
     break-unless before-cursor?
     cursor-row <- copy row
     cursor-column <- copy column
@@ -222,7 +222,7 @@ def render screen:address:screen, editor:address:editor-data -> last-row:number,
   return row, column, screen/same-as-ingredient:0, editor/same-as-ingredient:1
 ]
 
-def clear-screen-from screen:address:screen, row:number, column:number, left:number, right:number -> screen:address:screen [
+def clear-screen-from screen:&:screen, row:num, column:num, left:num, right:num -> screen:&:screen [
   local-scope
   load-ingredients
   # if it's the real screen, use the optimized primitive
@@ -238,14 +238,14 @@ def clear-screen-from screen:address:screen, row:number, column:number, left:num
   return screen/same-as-ingredient:0
 ]
 
-def clear-rest-of-screen screen:address:screen, row:number, left:number, right:number -> screen:address:screen [
+def clear-rest-of-screen screen:&:screen, row:num, left:num, right:num -> screen:&:screen [
   local-scope
   load-ingredients
   row <- add row, 1
   screen <- move-cursor screen, row, left
-  screen-height:number <- screen-height screen
+  screen-height:num <- screen-height screen
   {
-    at-bottom-of-screen?:boolean <- greater-or-equal row, screen-height
+    at-bottom-of-screen?:bool <- greater-or-equal row, screen-height
     break-if at-bottom-of-screen?
     screen <- move-cursor screen, row, left
     clear-line-until screen, right
@@ -259,7 +259,7 @@ scenario editor-initially-prints-multiple-lines [
   run [
     s:text <- new [abc
 def]
-    new-editor s:text, screen:address:screen, 0/left, 5/right
+    new-editor s:text, screen:&:screen, 0/left, 5/right
   ]
   screen-should-contain [
     .     .
@@ -273,7 +273,7 @@ scenario editor-initially-handles-offsets [
   assume-screen 5/width, 5/height
   run [
     s:text <- new [abc]
-    new-editor s:text, screen:address:screen, 1/left, 5/right
+    new-editor s:text, screen:&:screen, 1/left, 5/right
   ]
   screen-should-contain [
     .     .
@@ -287,7 +287,7 @@ scenario editor-initially-prints-multiple-lines-at-offset [
   run [
     s:text <- new [abc
 def]
-    new-editor s:text, screen:address:screen, 1/left, 5/right
+    new-editor s:text, screen:&:screen, 1/left, 5/right
   ]
   screen-should-contain [
     .     .
@@ -301,7 +301,7 @@ scenario editor-initially-wraps-long-lines [
   assume-screen 5/width, 5/height
   run [
     s:text <- new [abc def]
-    new-editor s:text, screen:address:screen, 0/left, 5/right
+    new-editor s:text, screen:&:screen, 0/left, 5/right
   ]
   screen-should-contain [
     .     .
@@ -321,7 +321,7 @@ scenario editor-initially-wraps-barely-long-lines [
   assume-screen 5/width, 5/height
   run [
     s:text <- new [abcde]
-    new-editor s:text, screen:address:screen, 0/left, 5/right
+    new-editor s:text, screen:&:screen, 0/left, 5/right
   ]
   # still wrap, even though the line would fit. We need room to click on the
   # end of the line
@@ -343,9 +343,9 @@ scenario editor-initializes-empty-text [
   assume-screen 5/width, 5/height
   run [
     1:text <- new []
-    2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .     .
@@ -366,7 +366,7 @@ scenario render-colors-comments [
     s:text <- new [abc
 # de
 f]
-    new-editor s:text, screen:address:screen, 0/left, 5/right
+    new-editor s:text, screen:&:screen, 0/left, 5/right
   ]
   screen-should-contain [
     .     .
@@ -396,14 +396,14 @@ after <character-c-received> [
 ]
 
 # so far the previous color is all the information we need; that may change
-def get-color color:number, c:character -> color:number [
+def get-color color:num, c:char -> color:num [
   local-scope
   load-ingredients
-  color-is-white?:boolean <- equal color, 7/white
+  color-is-white?:bool <- equal color, 7/white
   # if color is white and next character is '#', switch color to blue
   {
     break-unless color-is-white?
-    starting-comment?:boolean <- equal c, 35/#
+    starting-comment?:bool <- equal c, 35/#
     break-unless starting-comment?
     trace 90, [app], [switch color back to blue]
     color <- copy 12/lightblue
@@ -411,9 +411,9 @@ def get-color color:number, c:character -> color:number [
   }
   # if color is blue and next character is newline, switch color to white
   {
-    color-is-blue?:boolean <- equal color, 12/lightblue
+    color-is-blue?:bool <- equal color, 12/lightblue
     break-unless color-is-blue?
-    ending-comment?:boolean <- equal c, 10/newline
+    ending-comment?:bool <- equal c, 10/newline
     break-unless ending-comment?
     trace 90, [app], [switch color back to white]
     color <- copy 7/white
@@ -422,16 +422,16 @@ def get-color color:number, c:character -> color:number [
   # if color is white (no comments) and next character is '<', switch color to red
   {
     break-unless color-is-white?
-    starting-assignment?:boolean <- equal c, 60/<
+    starting-assignment?:bool <- equal c, 60/<
     break-unless starting-assignment?
     color <- copy 1/red
     jump +exit:label
   }
   # if color is red and next character is space, switch color to white
   {
-    color-is-red?:boolean <- equal color, 1/red
+    color-is-red?:bool <- equal color, 1/red
     break-unless color-is-red?
-    ending-assignment?:boolean <- equal c, 32/space
+    ending-assignment?:bool <- equal c, 32/space
     break-unless ending-assignment?
     color <- copy 7/white
     jump +exit:label
@@ -447,7 +447,7 @@ scenario render-colors-assignment [
     s:text <- new [abc
 d <- e
 f]
-    new-editor s:text, screen:address:screen, 0/left, 8/right
+    new-editor s:text, screen:&:screen, 0/left, 8/right
   ]
   screen-should-contain [
     .        .
diff --git a/edit/002-typing.mu b/edit/002-typing.mu
index d81cc991..08e82ad7 100644
--- a/edit/002-typing.mu
+++ b/edit/002-typing.mu
@@ -6,26 +6,26 @@ def! main text:text [
   local-scope
   load-ingredients
   open-console
-  editor:address:editor-data <- new-editor text, 0/screen, 5/left, 45/right
+  editor:&:editor-data <- new-editor text, 0/screen, 5/left, 45/right
   editor-event-loop 0/screen, 0/console, editor
   close-console
 ]
 
-def editor-event-loop screen:address:screen, console:address:console, editor:address:editor-data -> screen:address:screen, console:address:console, editor:address:editor-data [
+def editor-event-loop screen:&:screen, console:&:console, editor:&:editor-data -> screen:&:screen, console:&:console, editor:&:editor-data [
   local-scope
   load-ingredients
   {
     # looping over each (keyboard or touch) event as it occurs
     +next-event
-    cursor-row:number <- get *editor, cursor-row:offset
-    cursor-column:number <- get *editor, cursor-column:offset
+    cursor-row:num <- get *editor, cursor-row:offset
+    cursor-column:num <- get *editor, cursor-column:offset
     screen <- move-cursor screen, cursor-row, cursor-column
-    e:event, console:address:console, found?:boolean, quit?:boolean <- read-event console
+    e:event, console:&:console, found?:bool, quit?:bool <- read-event console
     loop-unless found?
     break-if quit?  # only in tests
     trace 10, [app], [next-event]
     # 'touch' event
-    t:touch-event, is-touch?:boolean <- maybe-convert e, touch:variant
+    t:touch-event, is-touch?:bool <- maybe-convert e, touch:variant
     {
       break-unless is-touch?
       move-cursor-in-editor screen, editor, t
@@ -34,7 +34,7 @@ def editor-event-loop screen:address:screen, console:address:console, editor:add
     # keyboard events
     {
       break-if is-touch?
-      screen, editor, go-render?:boolean <- handle-keyboard-event screen, editor, e
+      screen, editor, go-render?:bool <- handle-keyboard-event screen, editor, e
       {
         break-unless go-render?
         screen <- editor-render screen, editor
@@ -45,23 +45,23 @@ def editor-event-loop screen:address:screen, console:address:console, editor:add
 ]
 
 # process click, return if it was on current editor
-def move-cursor-in-editor screen:address:screen, editor:address:editor-data, t:touch-event -> in-focus?:boolean, editor:address:editor-data [
+def move-cursor-in-editor screen:&:screen, editor:&:editor-data, t:touch-event -> in-focus?:bool, editor:&:editor-data [
   local-scope
   load-ingredients
   return-unless editor, 0/false
-  click-row:number <- get t, row:offset
+  click-row:num <- get t, row:offset
   return-unless click-row, 0/false  # ignore clicks on 'menu'
-  click-column:number <- get t, column:offset
-  left:number <- get *editor, left:offset
-  too-far-left?:boolean <- lesser-than click-column, left
+  click-column:num <- get t, column:offset
+  left:num <- get *editor, left:offset
+  too-far-left?:bool <- lesser-than click-column, left
   return-if too-far-left?, 0/false
-  right:number <- get *editor, right:offset
-  too-far-right?:boolean <- greater-than click-column, right
+  right:num <- get *editor, right:offset
+  too-far-right?:bool <- greater-than click-column, right
   return-if too-far-right?, 0/false
   # position cursor
   <move-cursor-begin>
   editor <- snap-cursor screen, editor, click-row, click-column
-  undo-coalesce-tag:number <- copy 0/never
+  undo-coalesce-tag:num <- copy 0/never
   <move-cursor-end>
   # gain focus
   return 1/true
@@ -70,50 +70,50 @@ def move-cursor-in-editor screen:address:screen, editor:address:editor-data, t:t
 # Variant of 'render' that only moves the cursor (coordinates and
 # before-cursor). If it's past the end of a line, it 'slides' it left. If it's
 # past the last line it positions at end of last line.
-def snap-cursor screen:address:screen, editor:address:editor-data, target-row:number, target-column:number -> editor:address:editor-data [
+def snap-cursor screen:&:screen, editor:&:editor-data, target-row:num, target-column:num -> editor:&:editor-data [
   local-scope
   load-ingredients
   return-unless editor
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  screen-height:number <- screen-height screen
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  screen-height:num <- screen-height screen
   # count newlines until screen row
-  curr:address:duplex-list:character <- get *editor, top-of-screen:offset
-  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev
+  curr:&:duplex-list:char <- get *editor, top-of-screen:offset
+  prev:&:duplex-list:char <- copy curr  # just in case curr becomes null and we can't compute prev
   curr <- next curr
-  row:number <- copy 1/top
-  column:number <- copy left
+  row:num <- copy 1/top
+  column:num <- copy left
   *editor <- put *editor, cursor-row:offset, target-row
-  cursor-row:number <- copy target-row
+  cursor-row:num <- copy target-row
   *editor <- put *editor, cursor-column:offset, target-column
-  cursor-column:number <- copy target-column
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
+  cursor-column:num <- copy target-column
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
   {
     +next-character
     break-unless curr
-    off-screen?:boolean <- greater-or-equal row, screen-height
+    off-screen?:bool <- greater-or-equal row, screen-height
     break-if off-screen?
     # update editor-data.before-cursor
     # Doing so at the start of each iteration ensures it stays one step behind
     # the current character.
     {
-      at-cursor-row?:boolean <- equal row, cursor-row
+      at-cursor-row?:bool <- equal row, cursor-row
       break-unless at-cursor-row?
-      at-cursor?:boolean <- equal column, cursor-column
+      at-cursor?:bool <- equal column, cursor-column
       break-unless at-cursor?
       before-cursor <- copy prev
       *editor <- put *editor, before-cursor:offset, before-cursor
     }
-    c:character <- get *curr, value:offset
+    c:char <- get *curr, value:offset
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c, 10/newline
+      newline?:bool <- equal c, 10/newline
       break-unless newline?
       # adjust cursor if necessary
       {
-        at-cursor-row?:boolean <- equal row, cursor-row
+        at-cursor-row?:bool <- equal row, cursor-row
         break-unless at-cursor-row?
-        left-of-cursor?:boolean <- lesser-than column, cursor-column
+        left-of-cursor?:bool <- lesser-than column, cursor-column
         break-unless left-of-cursor?
         cursor-column <- copy column
         *editor <- put *editor, cursor-column:offset, cursor-column
@@ -130,7 +130,7 @@ def snap-cursor screen:address:screen, editor:address:editor-data, target-row:nu
     {
       # at right? wrap. even if there's only one more letter left; we need
       # room for clicking on the cursor after it.
-      at-right?:boolean <- equal column, right
+      at-right?:bool <- equal column, right
       break-unless at-right?
       column <- copy left
       row <- add row, 1
@@ -144,11 +144,11 @@ def snap-cursor screen:address:screen, editor:address:editor-data, target-row:nu
   }
   # is cursor to the right of the last line? move to end
   {
-    at-cursor-row?:boolean <- equal row, cursor-row
-    cursor-outside-line?:boolean <- lesser-or-equal column, cursor-column
-    before-cursor-on-same-line?:boolean <- and at-cursor-row?, cursor-outside-line?
-    above-cursor-row?:boolean <- lesser-than row, cursor-row
-    before-cursor?:boolean <- or before-cursor-on-same-line?, above-cursor-row?
+    at-cursor-row?:bool <- equal row, cursor-row
+    cursor-outside-line?:bool <- lesser-or-equal column, cursor-column
+    before-cursor-on-same-line?:bool <- and at-cursor-row?, cursor-outside-line?
+    above-cursor-row?:bool <- lesser-than row, cursor-row
+    before-cursor?:bool <- or before-cursor-on-same-line?, above-cursor-row?
     break-unless before-cursor?
     cursor-row <- copy row
     *editor <- put *editor, cursor-row:offset, cursor-row
@@ -161,39 +161,39 @@ def snap-cursor screen:address:screen, editor:address:editor-data, target-row:nu
 
 # Process an event 'e' and try to minimally update the screen.
 # Set 'go-render?' to true to indicate the caller must perform a non-minimal update.
-def handle-keyboard-event screen:address:screen, editor:address:editor-data, e:event -> screen:address:screen, editor:address:editor-data, go-render?:boolean [
+def handle-keyboard-event screen:&:screen, editor:&:editor-data, e:event -> screen:&:screen, editor:&:editor-data, go-render?:bool [
   local-scope
   load-ingredients
   go-render? <- copy 0/false
   return-unless editor
-  screen-width:number <- screen-width screen
-  screen-height:number <- screen-height screen
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  save-row:number <- copy cursor-row
-  save-column:number <- copy cursor-column
+  screen-width:num <- screen-width screen
+  screen-height:num <- screen-height screen
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  save-row:num <- copy cursor-row
+  save-column:num <- copy cursor-column
   # character
   {
-    c:character, is-unicode?:boolean <- maybe-convert e, text:variant
+    c:char, is-unicode?:bool <- maybe-convert e, text:variant
     break-unless is-unicode?
     trace 10, [app], [handle-keyboard-event: special character]
     # exceptions for special characters go here
     <handle-special-character>
     # ignore any other special characters
-    regular-character?:boolean <- greater-or-equal c, 32/space
+    regular-character?:bool <- greater-or-equal c, 32/space
     go-render? <- copy 0/false
     return-unless regular-character?
     # otherwise type it in
     <insert-character-begin>
-    editor, screen, go-render?:boolean <- insert-at-cursor editor, c, screen
+    editor, screen, go-render?:bool <- insert-at-cursor editor, c, screen
     <insert-character-end>
     return
   }
   # special key to modify the text or move the cursor
-  k:number, is-keycode?:boolean <- maybe-convert e:event, keycode:variant
+  k:num, is-keycode?:bool <- maybe-convert e:event, keycode:variant
   assert is-keycode?, [event was of unknown type; neither keyboard nor mouse]
   # handlers for each special key will go here
   <handle-special-key>
@@ -201,35 +201,35 @@ def handle-keyboard-event screen:address:screen, editor:address:editor-data, e:e
   return
 ]
 
-def insert-at-cursor editor:address:editor-data, c:character, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean [
+def insert-at-cursor editor:&:editor-data, c:char, screen:&:screen -> editor:&:editor-data, screen:&:screen, go-render?:bool [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
   insert c, before-cursor
   before-cursor <- next before-cursor
   *editor <- put *editor, before-cursor:offset, before-cursor
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  save-row:number <- copy cursor-row
-  save-column:number <- copy cursor-column
-  screen-width:number <- screen-width screen
-  screen-height:number <- screen-height screen
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  save-row:num <- copy cursor-row
+  save-column:num <- copy cursor-column
+  screen-width:num <- screen-width screen
+  screen-height:num <- screen-height screen
   # occasionally we'll need to mess with the cursor
   <insert-character-special-case>
   # but mostly we'll just move the cursor right
   cursor-column <- add cursor-column, 1
   *editor <- put *editor, cursor-column:offset, cursor-column
-  next:address:duplex-list:character <- next before-cursor
+  next:&:duplex-list:char <- next before-cursor
   {
     # at end of all text? no need to scroll? just print the character and leave
-    at-end?:boolean <- equal next, 0/null
+    at-end?:bool <- equal next, 0/null
     break-unless at-end?
-    bottom:number <- subtract screen-height, 1
-    at-bottom?:boolean <- equal save-row, bottom
-    at-right?:boolean <- equal save-column, right
-    overflow?:boolean <- and at-bottom?, at-right?
+    bottom:num <- subtract screen-height, 1
+    at-bottom?:bool <- equal save-row, bottom
+    at-right?:bool <- equal save-column, right
+    overflow?:bool <- and at-bottom?, at-right?
     break-if overflow?
     move-cursor screen, save-row, save-column
     print screen, c
@@ -239,20 +239,20 @@ def insert-at-cursor editor:address:editor-data, c:character, screen:address:scr
   {
     # not at right margin? print the character and rest of line
     break-unless next
-    at-right?:boolean <- greater-or-equal cursor-column, screen-width
+    at-right?:bool <- greater-or-equal cursor-column, screen-width
     break-if at-right?
-    curr:address:duplex-list:character <- copy before-cursor
+    curr:&:duplex-list:char <- copy before-cursor
     move-cursor screen, save-row, save-column
-    curr-column:number <- copy save-column
+    curr-column:num <- copy save-column
     {
       # hit right margin? give up and let caller render
       go-render? <- copy 1/true
-      at-right?:boolean <- greater-than curr-column, right
+      at-right?:bool <- greater-than curr-column, right
       return-if at-right?
       break-unless curr
       # newline? done.
-      currc:character <- get *curr, value:offset
-      at-newline?:boolean <- equal currc, 10/newline
+      currc:char <- get *curr, value:offset
+      at-newline?:bool <- equal currc, 10/newline
       break-if at-newline?
       print screen, currc
       curr-column <- add curr-column, 1
@@ -267,12 +267,12 @@ def insert-at-cursor editor:address:editor-data, c:character, screen:address:scr
 ]
 
 # helper for tests
-def editor-render screen:address:screen, editor:address:editor-data -> screen:address:screen, editor:address:editor-data [
+def editor-render screen:&:screen, editor:&:editor-data -> screen:&:screen, editor:&:editor-data [
   local-scope
   load-ingredients
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  row:number, column:number <- render screen, editor
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  row:num, column:num <- render screen, editor
   clear-line-until screen, right
   row <- add row, 1
   draw-horizontal screen, row, left, right, 9480/horizontal-dotted
@@ -283,11 +283,11 @@ def editor-render screen:address:screen, editor:address:editor-data -> screen:ad
 scenario editor-handles-empty-event-queue [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console []
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -300,16 +300,16 @@ scenario editor-handles-empty-event-queue [
 scenario editor-handles-mouse-clicks [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 1  # on the 'b'
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -327,15 +327,15 @@ scenario editor-handles-mouse-clicks [
 scenario editor-handles-mouse-clicks-outside-text [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   $clear-trace
   assume-console [
     left-click 1, 7  # last line, to the right of text
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # cursor row
@@ -348,15 +348,15 @@ scenario editor-handles-mouse-clicks-outside-text-2 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   $clear-trace
   assume-console [
     left-click 1, 7  # interior line, to the right of text
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # cursor row
@@ -369,15 +369,15 @@ scenario editor-handles-mouse-clicks-outside-text-3 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   $clear-trace
   assume-console [
     left-click 3, 7  # below text
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2  # cursor row
@@ -390,17 +390,17 @@ scenario editor-handles-mouse-clicks-outside-column [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
   # editor occupies only left half of screen
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     # click on right half of screen
     left-click 3, 8
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -418,17 +418,17 @@ scenario editor-handles-mouse-clicks-outside-column [
 scenario editor-handles-mouse-clicks-in-menu-area [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     # click on first, 'menu' row
     left-click 0, 3
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # no change to cursor
   memory-should-contain [
@@ -440,14 +440,14 @@ scenario editor-handles-mouse-clicks-in-menu-area [
 scenario editor-inserts-characters-into-empty-editor [
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     type [abc]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -461,8 +461,8 @@ scenario editor-inserts-characters-into-empty-editor [
 scenario editor-inserts-characters-at-cursor [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # type two letters at different places
   assume-console [
@@ -471,7 +471,7 @@ scenario editor-inserts-characters-at-cursor [
     type [d]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -485,15 +485,15 @@ scenario editor-inserts-characters-at-cursor [
 scenario editor-inserts-characters-at-cursor-2 [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 5  # right of last line
     type [d]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -508,15 +508,15 @@ scenario editor-inserts-characters-at-cursor-5 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 5  # right of non-last line
     type [e]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -531,15 +531,15 @@ d]
 scenario editor-inserts-characters-at-cursor-3 [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 3, 5  # below all text
     type [d]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -554,15 +554,15 @@ scenario editor-inserts-characters-at-cursor-4 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 3, 5  # below all text
     type [e]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -578,15 +578,15 @@ scenario editor-inserts-characters-at-cursor-6 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 3, 5  # below all text
     type [ef]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -601,13 +601,13 @@ d]
 scenario editor-moves-cursor-after-inserting-characters [
   assume-screen 10/width, 5/height
   1:text <- new [ab]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [01]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -622,14 +622,14 @@ scenario editor-moves-cursor-after-inserting-characters [
 scenario editor-wraps-line-on-insert [
   assume-screen 5/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   # type a letter
   assume-console [
     type [e]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # no wrap yet
   screen-should-contain [
@@ -644,7 +644,7 @@ scenario editor-wraps-line-on-insert [
     type [f]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # now wrap
   screen-should-contain [
@@ -661,17 +661,17 @@ scenario editor-wraps-line-on-insert-2 [
   assume-screen 10/width, 5/height
   1:text <- new [abcdefg
 defg]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   # type more text at the start
   assume-console [
     left-click 3, 0
     type [abc]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor is not wrapped
   memory-should-contain [
@@ -694,26 +694,26 @@ after <insert-character-special-case> [
     # if either:
     # a) we're at the end of the line and at the column of the wrap indicator, or
     # b) we're not at end of line and just before the column of the wrap indicator
-    wrap-column:number <- copy right
-    before-wrap-column:number <- subtract wrap-column, 1
-    at-wrap?:boolean <- greater-or-equal cursor-column, wrap-column
-    just-before-wrap?:boolean <- greater-or-equal cursor-column, before-wrap-column
-    next:address:duplex-list:character <- next before-cursor
+    wrap-column:num <- copy right
+    before-wrap-column:num <- subtract wrap-column, 1
+    at-wrap?:bool <- greater-or-equal cursor-column, wrap-column
+    just-before-wrap?:bool <- greater-or-equal cursor-column, before-wrap-column
+    next:&:duplex-list:char <- next before-cursor
     # at end of line? next == 0 || next.value == 10/newline
-    at-end-of-line?:boolean <- equal next, 0
+    at-end-of-line?:bool <- equal next, 0
     {
       break-if at-end-of-line?
-      next-character:character <- get *next, value:offset
+      next-character:char <- get *next, value:offset
       at-end-of-line? <- equal next-character, 10/newline
     }
     # break unless ((eol? and at-wrap?) or (~eol? and just-before-wrap?))
-    move-cursor-to-next-line?:boolean <- copy 0/false
+    move-cursor-to-next-line?:bool <- copy 0/false
     {
       break-if at-end-of-line?
       move-cursor-to-next-line? <- copy just-before-wrap?
       # if we're moving the cursor because it's in the middle of a wrapping
       # line, adjust it to left-most column
-      potential-new-cursor-column:number <- copy left
+      potential-new-cursor-column:num <- copy left
     }
     {
       break-unless at-end-of-line?
@@ -721,7 +721,7 @@ after <insert-character-special-case> [
       # if we're moving the cursor because it's at the end of a wrapping line,
       # adjust it to one past the left-most column to make room for the
       # newly-inserted wrap-indicator
-      potential-new-cursor-column:number <- add left, 1/make-room-for-wrap-indicator
+      potential-new-cursor-column:num <- add left, 1/make-room-for-wrap-indicator
     }
     break-unless move-cursor-to-next-line?
     cursor-column <- copy potential-new-cursor-column
@@ -730,7 +730,7 @@ after <insert-character-special-case> [
     *editor <- put *editor, cursor-row:offset, cursor-row
     # if we're out of the screen, scroll down
     {
-      below-screen?:boolean <- greater-or-equal cursor-row, screen-height
+      below-screen?:bool <- greater-or-equal cursor-row, screen-height
       break-unless below-screen?
       <scroll-down>
     }
@@ -742,15 +742,15 @@ after <insert-character-special-case> [
 scenario editor-wraps-cursor-after-inserting-characters-in-middle-of-line [
   assume-screen 10/width, 5/height
   1:text <- new [abcde]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   assume-console [
     left-click 1, 3  # right before the wrap icon
     type [f]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -771,7 +771,7 @@ scenario editor-wraps-cursor-after-inserting-characters-at-end-of-line [
   # create an editor containing two lines
   contents:text <- new [abc
 xyz]
-  1:address:editor-data/raw <- new-editor contents, screen, 0/left, 5/right
+  1:&:editor-data/raw <- new-editor contents, screen, 0/left, 5/right
   screen-should-contain [
     .          .
     .abc       .
@@ -783,7 +783,7 @@ xyz]
     type [de]  # trigger wrap
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 1:address:editor-data/raw
+    editor-event-loop screen:&:screen, console:&:console, 1:&:editor-data/raw
   ]
   screen-should-contain [
     .          .
@@ -797,15 +797,15 @@ xyz]
 scenario editor-wraps-cursor-to-left-margin [
   assume-screen 10/width, 5/height
   1:text <- new [abcde]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 2/left, 7/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 2/left, 7/right
   assume-console [
     left-click 1, 5  # line is full; no wrap icon yet
     type [01]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -823,7 +823,7 @@ scenario editor-wraps-cursor-to-left-margin [
 # if newline, move cursor to start of next line, and maybe align indent with previous line
 
 container editor-data [
-  indent?:boolean
+  indent?:bool
 ]
 
 after <editor-initialization> [
@@ -833,13 +833,13 @@ after <editor-initialization> [
 scenario editor-moves-cursor-down-after-inserting-newline [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   assume-console [
     type [0
 1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -852,7 +852,7 @@ scenario editor-moves-cursor-down-after-inserting-newline [
 
 after <handle-special-character> [
   {
-    newline?:boolean <- equal c, 10/newline
+    newline?:bool <- equal c, 10/newline
     break-unless newline?
     <insert-enter-begin>
     editor <- insert-new-line-and-indent editor, screen
@@ -862,15 +862,15 @@ after <handle-special-character> [
   }
 ]
 
-def insert-new-line-and-indent editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean [
+def insert-new-line-and-indent editor:&:editor-data, screen:&:screen -> editor:&:editor-data, screen:&:screen, go-render?:bool [
   local-scope
   load-ingredients
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  screen-height:number <- screen-height screen
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  screen-height:num <- screen-height screen
   # insert newline
   insert 10/newline, before-cursor
   before-cursor <- next before-cursor
@@ -881,7 +881,7 @@ def insert-new-line-and-indent editor:address:editor-data, screen:address:screen
   *editor <- put *editor, cursor-column:offset, cursor-column
   # maybe scroll
   {
-    below-screen?:boolean <- greater-or-equal cursor-row, screen-height  # must be equal, never greater
+    below-screen?:bool <- greater-or-equal cursor-row, screen-height  # must be equal, never greater
     break-unless below-screen?
     <scroll-down>
     go-render? <- copy 1/true
@@ -889,16 +889,16 @@ def insert-new-line-and-indent editor:address:editor-data, screen:address:screen
     *editor <- put *editor, cursor-row:offset, cursor-row
   }
   # indent if necessary
-  indent?:boolean <- get *editor, indent?:offset
+  indent?:bool <- get *editor, indent?:offset
   return-unless indent?
-  d:address:duplex-list:character <- get *editor, data:offset
-  end-of-previous-line:address:duplex-list:character <- prev before-cursor
-  indent:number <- line-indent end-of-previous-line, d
-  i:number <- copy 0
+  d:&:duplex-list:char <- get *editor, data:offset
+  end-of-previous-line:&:duplex-list:char <- prev before-cursor
+  indent:num <- line-indent end-of-previous-line, d
+  i:num <- copy 0
   {
-    indent-done?:boolean <- greater-or-equal i, indent
+    indent-done?:bool <- greater-or-equal i, indent
     break-if indent-done?
-    editor, screen, go-render?:boolean <- insert-at-cursor editor, 32/space, screen
+    editor, screen, go-render?:bool <- insert-at-cursor editor, 32/space, screen
     i <- add i, 1
     loop
   }
@@ -906,23 +906,23 @@ def insert-new-line-and-indent editor:address:editor-data, screen:address:screen
 
 # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
 # the number of spaces at the start of the line containing 'curr'.
-def line-indent curr:address:duplex-list:character, start:address:duplex-list:character -> result:number [
+def line-indent curr:&:duplex-list:char, start:&:duplex-list:char -> result:num [
   local-scope
   load-ingredients
-  result:number <- copy 0
+  result:num <- copy 0
   return-unless curr
-  at-start?:boolean <- equal curr, start
+  at-start?:bool <- equal curr, start
   return-if at-start?
   {
     curr <- prev curr
     break-unless curr
-    at-start?:boolean <- equal curr, start
+    at-start?:bool <- equal curr, start
     break-if at-start?
-    c:character <- get *curr, value:offset
-    at-newline?:boolean <- equal c, 10/newline
+    c:char <- get *curr, value:offset
+    at-newline?:bool <- equal c, 10/newline
     break-if at-newline?
     # if c is a space, increment result
-    is-space?:boolean <- equal c, 32/space
+    is-space?:bool <- equal c, 32/space
     {
       break-unless is-space?
       result <- add result, 1
@@ -939,13 +939,13 @@ def line-indent curr:address:duplex-list:character, start:address:duplex-list:ch
 scenario editor-moves-cursor-down-after-inserting-newline-2 [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 1/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 1/left, 10/right
   assume-console [
     type [0
 1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -959,7 +959,7 @@ scenario editor-moves-cursor-down-after-inserting-newline-2 [
 scenario editor-clears-previous-line-completely-after-inserting-newline [
   assume-screen 10/width, 5/height
   1:text <- new [abcde]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   assume-console [
     press enter
   ]
@@ -971,7 +971,7 @@ scenario editor-clears-previous-line-completely-after-inserting-newline [
     .          .
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # line should be fully cleared
   screen-should-contain [
@@ -988,7 +988,7 @@ scenario editor-inserts-indent-after-newline [
   1:text <- new [ab
   cd
 ef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # position cursor after 'cd' and hit 'newline'
   assume-console [
     left-click 2, 8
@@ -996,9 +996,9 @@ ef]
 ]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor should be below start of previous line
   memory-should-contain [
@@ -1012,7 +1012,7 @@ scenario editor-skips-indent-around-paste [
   1:text <- new [ab
   cd
 ef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # position cursor after 'cd' and hit 'newline' surrounded by paste markers
   assume-console [
     left-click 2, 8
@@ -1021,9 +1021,9 @@ ef]
     press 65506  # end paste
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor should be below start of previous line
   memory-should-contain [
@@ -1034,7 +1034,7 @@ ef]
 
 after <handle-special-key> [
   {
-    paste-start?:boolean <- equal k, 65507/paste-start
+    paste-start?:bool <- equal k, 65507/paste-start
     break-unless paste-start?
     *editor <- put *editor, indent?:offset, 0/false
     go-render? <- copy 1/true
@@ -1044,7 +1044,7 @@ after <handle-special-key> [
 
 after <handle-special-key> [
   {
-    paste-end?:boolean <- equal k, 65506/paste-end
+    paste-end?:bool <- equal k, 65506/paste-end
     break-unless paste-end?
     *editor <- put *editor, indent?:offset, 1/true
     go-render? <- copy 1/true
@@ -1054,28 +1054,28 @@ after <handle-special-key> [
 
 ## helpers
 
-def draw-horizontal screen:address:screen, row:number, x:number, right:number -> screen:address:screen [
+def draw-horizontal screen:&:screen, row:num, x:num, right:num -> screen:&:screen [
   local-scope
   load-ingredients
-  style:character, style-found?:boolean <- next-ingredient
+  style:char, style-found?:bool <- next-ingredient
   {
     break-if style-found?
     style <- copy 9472/horizontal
   }
-  color:number, color-found?:boolean <- next-ingredient
+  color:num, color-found?:bool <- next-ingredient
   {
     # default color to white
     break-if color-found?
     color <- copy 245/grey
   }
-  bg-color:number, bg-color-found?:boolean <- next-ingredient
+  bg-color:num, bg-color-found?:bool <- next-ingredient
   {
     break-if bg-color-found?
     bg-color <- copy 0/black
   }
   screen <- move-cursor screen, row, x
   {
-    continue?:boolean <- lesser-or-equal x, right  # right is inclusive, to match editor-data semantics
+    continue?:bool <- lesser-or-equal x, right  # right is inclusive, to match editor-data semantics
     break-unless continue?
     print screen, style, color, bg-color
     x <- add x, 1
diff --git a/edit/003-shortcuts.mu b/edit/003-shortcuts.mu
index 0de84d48..f2704a6a 100644
--- a/edit/003-shortcuts.mu
+++ b/edit/003-shortcuts.mu
@@ -9,12 +9,12 @@ scenario editor-inserts-two-spaces-on-tab [
   # just one character in final line
   1:text <- new [ab
 cd]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   assume-console [
     press tab
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -25,11 +25,11 @@ cd]
 
 after <handle-special-character> [
   {
-    tab?:boolean <- equal c, 9/tab
+    tab?:bool <- equal c, 9/tab
     break-unless tab?
     <insert-character-begin>
-    editor, screen, go-render?:boolean <- insert-at-cursor editor, 32/space, screen
-    editor, screen, go-render?:boolean <- insert-at-cursor editor, 32/space, screen
+    editor, screen, go-render?:bool <- insert-at-cursor editor, 32/space, screen
+    editor, screen, go-render?:bool <- insert-at-cursor editor, 32/space, screen
     <insert-character-end>
     go-render? <- copy 1/true
     return
@@ -41,17 +41,17 @@ after <handle-special-character> [
 scenario editor-handles-backspace-key [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 1
     press backspace
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -68,10 +68,10 @@ scenario editor-handles-backspace-key [
 
 after <handle-special-character> [
   {
-    delete-previous-character?:boolean <- equal c, 8/backspace
+    delete-previous-character?:bool <- equal c, 8/backspace
     break-unless delete-previous-character?
     <backspace-character-begin>
-    editor, screen, go-render?:boolean, backspaced-cell:address:duplex-list:character <- delete-before-cursor editor, screen
+    editor, screen, go-render?:bool, backspaced-cell:&:duplex-list:char <- delete-before-cursor editor, screen
     <backspace-character-end>
     return
   }
@@ -80,45 +80,45 @@ after <handle-special-character> [
 # return values:
 #   go-render? - whether caller needs to update the screen
 #   backspaced-cell - value deleted (or 0 if nothing was deleted) so we can save it for undo, etc.
-def delete-before-cursor editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean, backspaced-cell:address:duplex-list:character [
+def delete-before-cursor editor:&:editor-data, screen:&:screen -> editor:&:editor-data, screen:&:screen, go-render?:bool, backspaced-cell:&:duplex-list:char [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  data:address:duplex-list:character <- get *editor, data:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  data:&:duplex-list:char <- get *editor, data:offset
   # if at start of text (before-cursor at § sentinel), return
-  prev:address:duplex-list:character <- prev before-cursor
+  prev:&:duplex-list:char <- prev before-cursor
   go-render?, backspaced-cell <- copy 0/no-more-render, 0/nothing-deleted
   return-unless prev
   trace 10, [app], [delete-before-cursor]
-  original-row:number <- get *editor, cursor-row:offset
-  editor, scroll?:boolean <- move-cursor-coordinates-left editor
-  backspaced-cell:address:duplex-list:character <- copy before-cursor
+  original-row:num <- get *editor, cursor-row:offset
+  editor, scroll?:bool <- move-cursor-coordinates-left editor
+  backspaced-cell:&:duplex-list:char <- copy before-cursor
   data <- remove before-cursor, data  # will also neatly trim next/prev pointers in backspaced-cell/before-cursor
   before-cursor <- copy prev
   *editor <- put *editor, before-cursor:offset, before-cursor
   go-render? <- copy 1/true
   return-if scroll?
-  screen-width:number <- screen-width screen
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
+  screen-width:num <- screen-width screen
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
   # did we just backspace over a newline?
-  same-row?:boolean <- equal cursor-row, original-row
+  same-row?:bool <- equal cursor-row, original-row
   go-render? <- copy 1/true
   return-unless same-row?
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  curr:address:duplex-list:character <- next before-cursor
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  curr:&:duplex-list:char <- next before-cursor
   screen <- move-cursor screen, cursor-row, cursor-column
-  curr-column:number <- copy cursor-column
+  curr-column:num <- copy cursor-column
   {
     # hit right margin? give up and let caller render
-    at-right?:boolean <- greater-or-equal curr-column, right
+    at-right?:bool <- greater-or-equal curr-column, right
     go-render? <- copy 1/true
     return-if at-right?
     break-unless curr
     # newline? done.
-    currc:character <- get *curr, value:offset
-    at-newline?:boolean <- equal currc, 10/newline
+    currc:char <- get *curr, value:offset
+    at-newline?:bool <- equal currc, 10/newline
     break-if at-newline?
     screen <- print screen, currc
     curr-column <- add curr-column, 1
@@ -126,21 +126,21 @@ def delete-before-cursor editor:address:editor-data, screen:address:screen -> ed
     loop
   }
   # we're guaranteed not to be at the right margin
-  space:character <- copy 32/space
+  space:char <- copy 32/space
   screen <- print screen, space
   go-render? <- copy 0/false
 ]
 
-def move-cursor-coordinates-left editor:address:editor-data -> editor:address:editor-data, go-render?:boolean [
+def move-cursor-coordinates-left editor:&:editor-data -> editor:&:editor-data, go-render?:bool [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  left:number <- get *editor, left:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  left:num <- get *editor, left:offset
   # if not at left margin, move one character left
   {
-    at-left-margin?:boolean <- equal cursor-column, left
+    at-left-margin?:bool <- equal cursor-column, left
     break-if at-left-margin?
     trace 10, [app], [decrementing cursor column]
     cursor-column <- subtract cursor-column, 1
@@ -149,8 +149,8 @@ def move-cursor-coordinates-left editor:address:editor-data -> editor:address:ed
     return
   }
   # if at left margin, we must move to previous row:
-  top-of-screen?:boolean <- equal cursor-row, 1  # exclude menu bar
-  go-render?:boolean <- copy 0/false
+  top-of-screen?:bool <- equal cursor-row, 1  # exclude menu bar
+  go-render?:bool <- copy 0/false
   {
     break-if top-of-screen?
     cursor-row <- subtract cursor-row, 1
@@ -163,19 +163,19 @@ def move-cursor-coordinates-left editor:address:editor-data -> editor:address:ed
   }
   {
     # case 1: if previous character was newline, figure out how long the previous line is
-    previous-character:character <- get *before-cursor, value:offset
-    previous-character-is-newline?:boolean <- equal previous-character, 10/newline
+    previous-character:char <- get *before-cursor, value:offset
+    previous-character-is-newline?:bool <- equal previous-character, 10/newline
     break-unless previous-character-is-newline?
     # compute length of previous line
     trace 10, [app], [switching to previous line]
-    d:address:duplex-list:character <- get *editor, data:offset
-    end-of-line:number <- previous-line-length before-cursor, d
-    right:number <- get *editor, right:offset
-    width:number <- subtract right, left
-    wrap?:boolean <- greater-than end-of-line, width
+    d:&:duplex-list:char <- get *editor, data:offset
+    end-of-line:num <- previous-line-length before-cursor, d
+    right:num <- get *editor, right:offset
+    width:num <- subtract right, left
+    wrap?:bool <- greater-than end-of-line, width
     {
       break-unless wrap?
-      _, column-offset:number <- divide-with-remainder end-of-line, width
+      _, column-offset:num <- divide-with-remainder end-of-line, width
       cursor-column <- add left, column-offset
       *editor <- put *editor, cursor-column:offset, cursor-column
     }
@@ -188,27 +188,27 @@ def move-cursor-coordinates-left editor:address:editor-data -> editor:address:ed
   }
   # case 2: if previous-character was not newline, we're just at a wrapped line
   trace 10, [app], [wrapping to previous line]
-  right:number <- get *editor, right:offset
+  right:num <- get *editor, right:offset
   cursor-column <- subtract right, 1  # leave room for wrap icon
   *editor <- put *editor, cursor-column:offset, cursor-column
 ]
 
 # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
 # the length of the previous line before the 'curr' pointer.
-def previous-line-length curr:address:duplex-list:character, start:address:duplex-list:character -> result:number [
+def previous-line-length curr:&:duplex-list:char, start:&:duplex-list:char -> result:num [
   local-scope
   load-ingredients
-  result:number <- copy 0
+  result:num <- copy 0
   return-unless curr
-  at-start?:boolean <- equal curr, start
+  at-start?:bool <- equal curr, start
   return-if at-start?
   {
     curr <- prev curr
     break-unless curr
-    at-start?:boolean <- equal curr, start
+    at-start?:bool <- equal curr, start
     break-if at-start?
-    c:character <- get *curr, value:offset
-    at-newline?:boolean <- equal c, 10/newline
+    c:char <- get *curr, value:offset
+    at-newline?:bool <- equal c, 10/newline
     break-if at-newline?
     result <- add result, 1
     loop
@@ -220,15 +220,15 @@ scenario editor-clears-last-line-on-backspace [
   # just one character in final line
   1:text <- new [ab
 cd]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   assume-console [
     left-click 2, 0  # cursor at only character in final line
     press backspace
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -247,8 +247,8 @@ scenario editor-joins-and-wraps-lines-on-backspace [
   # initialize editor with two long-ish but non-wrapping lines
   1:text <- new [abc def
 ghi jkl]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position the cursor at the start of the second and hit backspace
   assume-console [
@@ -256,7 +256,7 @@ ghi jkl]
     press backspace
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # resulting single line should wrap correctly
   screen-should-contain [
@@ -272,8 +272,8 @@ scenario editor-wraps-long-lines-on-backspace [
   assume-screen 10/width, 5/height
   # initialize editor in part of the screen with a long line
   1:text <- new [abc def ghij]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 8/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 8/right
+  editor-render screen, 2:&:editor-data
   # confirm that it wraps
   screen-should-contain [
     .          .
@@ -288,7 +288,7 @@ scenario editor-wraps-long-lines-on-backspace [
     press backspace
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # resulting single line should wrap correctly and not overflow its bounds
   screen-should-contain [
@@ -305,14 +305,14 @@ scenario editor-wraps-long-lines-on-backspace [
 scenario editor-handles-delete-key [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     press delete
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -326,7 +326,7 @@ scenario editor-handles-delete-key [
     press delete
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -339,44 +339,44 @@ scenario editor-handles-delete-key [
 
 after <handle-special-key> [
   {
-    delete-next-character?:boolean <- equal k, 65522/delete
+    delete-next-character?:bool <- equal k, 65522/delete
     break-unless delete-next-character?
     <delete-character-begin>
-    editor, screen, go-render?:boolean, deleted-cell:address:duplex-list:character <- delete-at-cursor editor, screen
+    editor, screen, go-render?:bool, deleted-cell:&:duplex-list:char <- delete-at-cursor editor, screen
     <delete-character-end>
     return
   }
 ]
 
-def delete-at-cursor editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean, deleted-cell:address:duplex-list:character [
+def delete-at-cursor editor:&:editor-data, screen:&:screen -> editor:&:editor-data, screen:&:screen, go-render?:bool, deleted-cell:&:duplex-list:char [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  data:address:duplex-list:character <- get *editor, data:offset
-  deleted-cell:address:duplex-list:character <- next before-cursor
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  data:&:duplex-list:char <- get *editor, data:offset
+  deleted-cell:&:duplex-list:char <- next before-cursor
   go-render? <- copy 0/false
   return-unless deleted-cell
-  currc:character <- get *deleted-cell, value:offset
+  currc:char <- get *deleted-cell, value:offset
   data <- remove deleted-cell, data
-  deleted-newline?:boolean <- equal currc, 10/newline
+  deleted-newline?:bool <- equal currc, 10/newline
   go-render? <- copy 1/true
   return-if deleted-newline?
   # wasn't a newline? render rest of line
-  curr:address:duplex-list:character <- next before-cursor  # refresh after remove above
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
+  curr:&:duplex-list:char <- next before-cursor  # refresh after remove above
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
   screen <- move-cursor screen, cursor-row, cursor-column
-  curr-column:number <- copy cursor-column
-  screen-width:number <- screen-width screen
+  curr-column:num <- copy cursor-column
+  screen-width:num <- screen-width screen
   {
     # hit right margin? give up and let caller render
-    at-right?:boolean <- greater-or-equal curr-column, screen-width
+    at-right?:bool <- greater-or-equal curr-column, screen-width
     go-render? <- copy 1/true
     return-if at-right?
     break-unless curr
     # newline? done.
-    currc:character <- get *curr, value:offset
-    at-newline?:boolean <- equal currc, 10/newline
+    currc:char <- get *curr, value:offset
+    at-newline?:bool <- equal currc, 10/newline
     break-if at-newline?
     screen <- print screen, currc
     curr-column <- add curr-column, 1
@@ -384,7 +384,7 @@ def delete-at-cursor editor:address:editor-data, screen:address:screen -> editor
     loop
   }
   # we're guaranteed not to be at the right margin
-  space:character <- copy 32/space
+  space:char <- copy 32/space
   screen <- print screen, space
   go-render? <- copy 0/false
 ]
@@ -394,15 +394,15 @@ def delete-at-cursor editor:address:editor-data, screen:address:screen -> editor
 scenario editor-moves-cursor-right-with-key [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     press right-arrow
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -415,41 +415,41 @@ scenario editor-moves-cursor-right-with-key [
 
 after <handle-special-key> [
   {
-    move-to-next-character?:boolean <- equal k, 65514/right-arrow
+    move-to-next-character?:bool <- equal k, 65514/right-arrow
     break-unless move-to-next-character?
     # if not at end of text
-    next-cursor:address:duplex-list:character <- next before-cursor
+    next-cursor:&:duplex-list:char <- next before-cursor
     break-unless next-cursor
     # scan to next character
     <move-cursor-begin>
     before-cursor <- copy next-cursor
     *editor <- put *editor, before-cursor:offset, before-cursor
-    editor, go-render?:boolean <- move-cursor-coordinates-right editor, screen-height
+    editor, go-render?:bool <- move-cursor-coordinates-right editor, screen-height
     screen <- move-cursor screen, cursor-row, cursor-column
-    undo-coalesce-tag:number <- copy 2/right-arrow
+    undo-coalesce-tag:num <- copy 2/right-arrow
     <move-cursor-end>
     return
   }
 ]
 
-def move-cursor-coordinates-right editor:address:editor-data, screen-height:number -> editor:address:editor-data, go-render?:boolean [
+def move-cursor-coordinates-right editor:&:editor-data, screen-height:num -> editor:&:editor-data, go-render?:bool [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor before-cursor:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
+  before-cursor:&:duplex-list:char <- get *editor before-cursor:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
   # if crossed a newline, move cursor to start of next row
   {
-    old-cursor-character:character <- get *before-cursor, value:offset
-    was-at-newline?:boolean <- equal old-cursor-character, 10/newline
+    old-cursor-character:char <- get *before-cursor, value:offset
+    was-at-newline?:bool <- equal old-cursor-character, 10/newline
     break-unless was-at-newline?
     cursor-row <- add cursor-row, 1
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- copy left
     *editor <- put *editor, cursor-column:offset, cursor-column
-    below-screen?:boolean <- greater-or-equal cursor-row, screen-height  # must be equal
+    below-screen?:bool <- greater-or-equal cursor-row, screen-height  # must be equal
     go-render? <- copy 0/false
     return-unless below-screen?
     <scroll-down>
@@ -461,20 +461,20 @@ def move-cursor-coordinates-right editor:address:editor-data, screen-height:numb
   # if the line wraps, move cursor to start of next row
   {
     # if we're at the column just before the wrap indicator
-    wrap-column:number <- subtract right, 1
-    at-wrap?:boolean <- equal cursor-column, wrap-column
+    wrap-column:num <- subtract right, 1
+    at-wrap?:bool <- equal cursor-column, wrap-column
     break-unless at-wrap?
     # and if next character isn't newline
-    next:address:duplex-list:character <- next before-cursor
+    next:&:duplex-list:char <- next before-cursor
     break-unless next
-    next-character:character <- get *next, value:offset
-    newline?:boolean <- equal next-character, 10/newline
+    next-character:char <- get *next, value:offset
+    newline?:bool <- equal next-character, 10/newline
     break-if newline?
     cursor-row <- add cursor-row, 1
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- copy left
     *editor <- put *editor, cursor-column:offset, cursor-column
-    below-screen?:boolean <- greater-or-equal cursor-row, screen-height  # must be equal
+    below-screen?:bool <- greater-or-equal cursor-row, screen-height  # must be equal
     return-unless below-screen?, editor/same-as-ingredient:0, 0/no-more-render
     <scroll-down>
     cursor-row <- subtract cursor-row, 1  # bring back into screen range
@@ -492,8 +492,8 @@ scenario editor-moves-cursor-to-next-line-with-right-arrow [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # type right-arrow a few times to get to start of second line
   assume-console [
@@ -503,7 +503,7 @@ d]
     press right-arrow  # next line
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   check-trace-count-for-label 0, [print-character]
   # type something and ensure it goes where it should
@@ -511,7 +511,7 @@ d]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -527,8 +527,8 @@ scenario editor-moves-cursor-to-next-line-with-right-arrow-2 [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 1/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 1/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     press right-arrow
     press right-arrow
@@ -537,7 +537,7 @@ d]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -551,17 +551,17 @@ d]
 scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow [
   assume-screen 10/width, 5/height
   1:text <- new [abcdef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 3
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -581,8 +581,8 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
   assume-screen 10/width, 5/height
   # line just barely wrapping
   1:text <- new [abcde]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position cursor at last character before wrap and hit right-arrow
   assume-console [
@@ -590,9 +590,9 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -603,9 +603,9 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -617,17 +617,17 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
 scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-3 [
   assume-screen 10/width, 5/height
   1:text <- new [abcdef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 1/left, 6/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 1/left, 6/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 4
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -647,8 +647,8 @@ scenario editor-moves-cursor-to-next-line-with-right-arrow-at-end-of-line [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # move to end of line, press right-arrow, type a character
   assume-console [
@@ -657,7 +657,7 @@ d]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # new character should be in next line
   screen-should-contain [
@@ -677,8 +677,8 @@ d]
 scenario editor-moves-cursor-left-with-key [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 2
@@ -686,7 +686,7 @@ scenario editor-moves-cursor-left-with-key [
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -699,18 +699,18 @@ scenario editor-moves-cursor-left-with-key [
 
 after <handle-special-key> [
   {
-    move-to-previous-character?:boolean <- equal k, 65515/left-arrow
+    move-to-previous-character?:bool <- equal k, 65515/left-arrow
     break-unless move-to-previous-character?
     trace 10, [app], [left arrow]
     # if not at start of text (before-cursor at § sentinel)
-    prev:address:duplex-list:character <- prev before-cursor
+    prev:&:duplex-list:char <- prev before-cursor
     go-render? <- copy 0/false
     return-unless prev
     <move-cursor-begin>
     editor, go-render? <- move-cursor-coordinates-left editor
     before-cursor <- copy prev
     *editor <- put *editor, before-cursor:offset, before-cursor
-    undo-coalesce-tag:number <- copy 1/left-arrow
+    undo-coalesce-tag:num <- copy 1/left-arrow
     <move-cursor-end>
     return
   }
@@ -721,8 +721,8 @@ scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line [
   # initialize editor with two lines
   1:text <- new [abc
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position cursor at start of second line (so there's no previous newline)
   assume-console [
@@ -730,9 +730,9 @@ d]
     press left-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -747,8 +747,8 @@ scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-2
   1:text <- new [abc
 def
 g]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position cursor further down (so there's a newline before the character at
   # the cursor)
@@ -758,7 +758,7 @@ g]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -775,8 +775,8 @@ scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-3
   1:text <- new [abc
 def
 g]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position cursor at start of text, press left-arrow, then type a character
   assume-console [
@@ -785,7 +785,7 @@ g]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # left-arrow should have had no effect
   screen-should-contain [
@@ -804,8 +804,8 @@ scenario editor-moves-cursor-to-previous-line-with-left-arrow-at-start-of-line-4
   1:text <- new [abc
 
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # position cursor right after empty line
   assume-console [
@@ -814,7 +814,7 @@ d]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -830,8 +830,8 @@ scenario editor-moves-across-screen-lines-across-wrap-with-left-arrow [
   assume-screen 10/width, 5/height
   # initialize editor with a wrapping line
   1:text <- new [abcdef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   screen-should-contain [
     .          .
@@ -846,9 +846,9 @@ scenario editor-moves-across-screen-lines-across-wrap-with-left-arrow [
     press left-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # previous row
@@ -862,8 +862,8 @@ scenario editor-moves-across-screen-lines-to-wrapping-line-with-left-arrow [
   # initialize editor with a wrapping line followed by a second line
   1:text <- new [abcdef
 g]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   screen-should-contain [
     .          .
@@ -878,9 +878,9 @@ g]
     press left-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2  # previous row
@@ -894,8 +894,8 @@ scenario editor-moves-across-screen-lines-to-non-wrapping-line-with-left-arrow [
   # initialize editor with a line on the verge of wrapping, followed by a second line
   1:text <- new [abcd
 e]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   screen-should-contain [
     .          .
@@ -910,9 +910,9 @@ e]
     press left-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # previous row
@@ -929,17 +929,17 @@ scenario editor-moves-to-previous-line-with-up-arrow [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 2, 1
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -950,7 +950,7 @@ def]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -963,46 +963,46 @@ def]
 
 after <handle-special-key> [
   {
-    move-to-previous-line?:boolean <- equal k, 65517/up-arrow
+    move-to-previous-line?:bool <- equal k, 65517/up-arrow
     break-unless move-to-previous-line?
     <move-cursor-begin>
     editor, go-render? <- move-to-previous-line editor
-    undo-coalesce-tag:number <- copy 3/up-arrow
+    undo-coalesce-tag:num <- copy 3/up-arrow
     <move-cursor-end>
     return
   }
 ]
 
-def move-to-previous-line editor:address:editor-data -> editor:address:editor-data, go-render?:boolean [
+def move-to-previous-line editor:&:editor-data -> editor:&:editor-data, go-render?:bool [
   local-scope
   load-ingredients
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  already-at-top?:boolean <- lesser-or-equal cursor-row, 1/top
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  already-at-top?:bool <- lesser-or-equal cursor-row, 1/top
   {
     # if cursor not at top, move it
     break-if already-at-top?
     # if not at newline, move to start of line (previous newline)
     # then scan back another line
     # if either step fails, give up without modifying cursor or coordinates
-    curr:address:duplex-list:character <- copy before-cursor
+    curr:&:duplex-list:char <- copy before-cursor
     {
-      old:address:duplex-list:character <- copy curr
-      c2:character <- get *curr, value:offset
-      at-newline?:boolean <- equal c2, 10/newline
+      old:&:duplex-list:char <- copy curr
+      c2:char <- get *curr, value:offset
+      at-newline?:bool <- equal c2, 10/newline
       break-if at-newline?
-      curr:address:duplex-list:character <- before-previous-line curr, editor
-      no-motion?:boolean <- equal curr, old
+      curr:&:duplex-list:char <- before-previous-line curr, editor
+      no-motion?:bool <- equal curr, old
       go-render? <- copy 0/false
       return-if no-motion?
     }
     {
       old <- copy curr
       curr <- before-previous-line curr, editor
-      no-motion?:boolean <- equal curr, old
+      no-motion?:bool <- equal curr, old
       go-render? <- copy 0/false
       return-if no-motion?
     }
@@ -1011,16 +1011,16 @@ def move-to-previous-line editor:address:editor-data -> editor:address:editor-da
     cursor-row <- subtract cursor-row, 1
     *editor <- put *editor, cursor-row:offset, cursor-row
     # scan ahead to right column or until end of line
-    target-column:number <- copy cursor-column
+    target-column:num <- copy cursor-column
     cursor-column <- copy left
     *editor <- put *editor, cursor-column:offset, cursor-column
     {
-      done?:boolean <- greater-or-equal cursor-column, target-column
+      done?:bool <- greater-or-equal cursor-column, target-column
       break-if done?
-      curr:address:duplex-list:character <- next before-cursor
+      curr:&:duplex-list:char <- next before-cursor
       break-unless curr
-      currc:character <- get *curr, value:offset
-      at-newline?:boolean <- equal currc, 10/newline
+      currc:char <- get *curr, value:offset
+      at-newline?:bool <- equal currc, 10/newline
       break-if at-newline?
       #
       before-cursor <- copy curr
@@ -1045,17 +1045,17 @@ scenario editor-adjusts-column-at-previous-line [
   assume-screen 10/width, 5/height
   1:text <- new [ab
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 2, 3
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -1066,7 +1066,7 @@ def]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1081,17 +1081,17 @@ scenario editor-adjusts-column-at-empty-line [
   assume-screen 10/width, 5/height
   1:text <- new [
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 2, 3
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -1102,7 +1102,7 @@ def]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1119,8 +1119,8 @@ scenario editor-moves-to-previous-line-from-left-margin [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # click on the third line and hit up-arrow, so you end up just after a newline
   assume-console [
@@ -1128,9 +1128,9 @@ ghi]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -1141,7 +1141,7 @@ ghi]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1158,17 +1158,17 @@ scenario editor-moves-to-next-line-with-down-arrow [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # cursor starts out at (1, 0)
   assume-console [
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # ..and ends at (2, 0)
   memory-should-contain [
@@ -1180,7 +1180,7 @@ def]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1193,38 +1193,38 @@ def]
 
 after <handle-special-key> [
   {
-    move-to-next-line?:boolean <- equal k, 65516/down-arrow
+    move-to-next-line?:bool <- equal k, 65516/down-arrow
     break-unless move-to-next-line?
     <move-cursor-begin>
     editor, go-render? <- move-to-next-line editor, screen-height
-    undo-coalesce-tag:number <- copy 4/down-arrow
+    undo-coalesce-tag:num <- copy 4/down-arrow
     <move-cursor-end>
     return
   }
 ]
 
-def move-to-next-line editor:address:editor-data, screen-height:number -> editor:address:editor-data, go-render?:boolean [
+def move-to-next-line editor:&:editor-data, screen-height:num -> editor:&:editor-data, go-render?:bool [
   local-scope
   load-ingredients
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  last-line:number <- subtract screen-height, 1
-  already-at-bottom?:boolean <- greater-or-equal cursor-row, last-line
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  last-line:num <- subtract screen-height, 1
+  already-at-bottom?:bool <- greater-or-equal cursor-row, last-line
   {
     # if cursor not at bottom, move it
     break-if already-at-bottom?
     # scan to start of next line, then to right column or until end of line
-    max:number <- subtract right, left
-    next-line:address:duplex-list:character <- before-start-of-next-line before-cursor, max
+    max:num <- subtract right, left
+    next-line:&:duplex-list:char <- before-start-of-next-line before-cursor, max
     {
       # already at end of buffer? try to scroll up (so we can see more
       # warnings or sandboxes below)
-      no-motion?:boolean <- equal next-line, before-cursor
+      no-motion?:bool <- equal next-line, before-cursor
       break-unless no-motion?
-      scroll?:boolean <- greater-than cursor-row, 1
+      scroll?:bool <- greater-than cursor-row, 1
       break-if scroll?, +try-to-scroll:label
       go-render? <- copy 0/false
       return
@@ -1233,16 +1233,16 @@ def move-to-next-line editor:address:editor-data, screen-height:number -> editor
     *editor <- put *editor, cursor-row:offset, cursor-row
     before-cursor <- copy next-line
     *editor <- put *editor, before-cursor:offset, before-cursor
-    target-column:number <- copy cursor-column
+    target-column:num <- copy cursor-column
     cursor-column <- copy left
     *editor <- put *editor, cursor-column:offset, cursor-column
     {
-      done?:boolean <- greater-or-equal cursor-column, target-column
+      done?:bool <- greater-or-equal cursor-column, target-column
       break-if done?
-      curr:address:duplex-list:character <- next before-cursor
+      curr:&:duplex-list:char <- next before-cursor
       break-unless curr
-      currc:character <- get *curr, value:offset
-      at-newline?:boolean <- equal currc, 10/newline
+      currc:char <- get *curr, value:offset
+      at-newline?:bool <- equal currc, 10/newline
       break-if at-newline?
       #
       before-cursor <- copy curr
@@ -1263,17 +1263,17 @@ scenario editor-adjusts-column-at-next-line [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 de]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   assume-console [
     left-click 1, 3
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -1284,7 +1284,7 @@ de]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1301,8 +1301,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-a [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on second line, press ctrl-a
   assume-console [
@@ -1310,9 +1310,9 @@ scenario editor-moves-to-start-of-line-with-ctrl-a [
     press ctrl-a
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -1324,11 +1324,11 @@ scenario editor-moves-to-start-of-line-with-ctrl-a [
 
 after <handle-special-character> [
   {
-    move-to-start-of-line?:boolean <- equal c, 1/ctrl-a
+    move-to-start-of-line?:bool <- equal c, 1/ctrl-a
     break-unless move-to-start-of-line?
     <move-cursor-begin>
     move-to-start-of-line editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
     go-render? <- copy 0/false
     return
@@ -1337,33 +1337,33 @@ after <handle-special-character> [
 
 after <handle-special-key> [
   {
-    move-to-start-of-line?:boolean <- equal k, 65521/home
+    move-to-start-of-line?:bool <- equal k, 65521/home
     break-unless move-to-start-of-line?
     <move-cursor-begin>
     move-to-start-of-line editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
     go-render? <- copy 0/false
     return
   }
 ]
 
-def move-to-start-of-line editor:address:editor-data -> editor:address:editor-data [
+def move-to-start-of-line editor:&:editor-data -> editor:&:editor-data [
   local-scope
   load-ingredients
   # update cursor column
-  left:number <- get *editor, left:offset
-  cursor-column:number <- copy left
+  left:num <- get *editor, left:offset
+  cursor-column:num <- copy left
   *editor <- put *editor, cursor-column:offset, cursor-column
   # update before-cursor
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  init:address:duplex-list:character <- get *editor, data:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  init:&:duplex-list:char <- get *editor, data:offset
   # while not at start of line, move 
   {
-    at-start-of-text?:boolean <- equal before-cursor, init
+    at-start-of-text?:bool <- equal before-cursor, init
     break-if at-start-of-text?
-    prev:character <- get *before-cursor, value:offset
-    at-start-of-line?:boolean <- equal prev, 10/newline
+    prev:char <- get *before-cursor, value:offset
+    at-start-of-line?:bool <- equal prev, 10/newline
     break-if at-start-of-line?
     before-cursor <- prev before-cursor
     *editor <- put *editor, before-cursor:offset, before-cursor
@@ -1376,8 +1376,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-a-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on first line (no newline before), press ctrl-a
   assume-console [
@@ -1385,9 +1385,9 @@ scenario editor-moves-to-start-of-line-with-ctrl-a-2 [
     press ctrl-a
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -1401,7 +1401,7 @@ scenario editor-moves-to-start-of-line-with-home [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   $clear-trace
   # start on second line, press 'home'
   assume-console [
@@ -1409,9 +1409,9 @@ scenario editor-moves-to-start-of-line-with-home [
     press home
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -1425,8 +1425,8 @@ scenario editor-moves-to-start-of-line-with-home-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on first line (no newline before), press 'home'
   assume-console [
@@ -1434,9 +1434,9 @@ scenario editor-moves-to-start-of-line-with-home-2 [
     press home
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -1452,8 +1452,8 @@ scenario editor-moves-to-end-of-line-with-ctrl-e [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on first line, press ctrl-e
   assume-console [
@@ -1461,9 +1461,9 @@ scenario editor-moves-to-end-of-line-with-ctrl-e [
     press ctrl-e
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -1476,9 +1476,9 @@ scenario editor-moves-to-end-of-line-with-ctrl-e [
     type [z]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     4 <- 1
@@ -1496,11 +1496,11 @@ scenario editor-moves-to-end-of-line-with-ctrl-e [
 
 after <handle-special-character> [
   {
-    move-to-end-of-line?:boolean <- equal c, 5/ctrl-e
+    move-to-end-of-line?:bool <- equal c, 5/ctrl-e
     break-unless move-to-end-of-line?
     <move-cursor-begin>
     move-to-end-of-line editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
     go-render? <- copy 0/false
     return
@@ -1509,28 +1509,28 @@ after <handle-special-character> [
 
 after <handle-special-key> [
   {
-    move-to-end-of-line?:boolean <- equal k, 65520/end
+    move-to-end-of-line?:bool <- equal k, 65520/end
     break-unless move-to-end-of-line?
     <move-cursor-begin>
     move-to-end-of-line editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
     go-render? <- copy 0/false
     return
   }
 ]
 
-def move-to-end-of-line editor:address:editor-data -> editor:address:editor-data [
+def move-to-end-of-line editor:&:editor-data -> editor:&:editor-data [
   local-scope
   load-ingredients
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  cursor-column:number <- get *editor, cursor-column:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  cursor-column:num <- get *editor, cursor-column:offset
   # while not at start of line, move 
   {
-    next:address:duplex-list:character <- next before-cursor
+    next:&:duplex-list:char <- next before-cursor
     break-unless next  # end of text
-    nextc:character <- get *next, value:offset
-    at-end-of-line?:boolean <- equal nextc, 10/newline
+    nextc:char <- get *next, value:offset
+    at-end-of-line?:bool <- equal nextc, 10/newline
     break-if at-end-of-line?
     before-cursor <- copy next
     *editor <- put *editor, before-cursor:offset, before-cursor
@@ -1544,8 +1544,8 @@ scenario editor-moves-to-end-of-line-with-ctrl-e-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on second line (no newline after), press ctrl-e
   assume-console [
@@ -1553,9 +1553,9 @@ scenario editor-moves-to-end-of-line-with-ctrl-e-2 [
     press ctrl-e
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    4:number <- get *2:address:editor-data, cursor-row:offset
-    5:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    4:num <- get *2:&:editor-data, cursor-row:offset
+    5:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -1569,8 +1569,8 @@ scenario editor-moves-to-end-of-line-with-end [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on first line, press 'end'
   assume-console [
@@ -1578,9 +1578,9 @@ scenario editor-moves-to-end-of-line-with-end [
     press end
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -1594,8 +1594,8 @@ scenario editor-moves-to-end-of-line-with-end-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # start on second line (no newline after), press 'end'
   assume-console [
@@ -1603,9 +1603,9 @@ scenario editor-moves-to-end-of-line-with-end-2 [
     press end
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -1621,14 +1621,14 @@ scenario editor-deletes-to-start-of-line-with-ctrl-u [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start on second line, press ctrl-u
   assume-console [
     left-click 2, 2
     press ctrl-u
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to start of line
   screen-should-contain [
@@ -1642,41 +1642,41 @@ scenario editor-deletes-to-start-of-line-with-ctrl-u [
 
 after <handle-special-character> [
   {
-    delete-to-start-of-line?:boolean <- equal c, 21/ctrl-u
+    delete-to-start-of-line?:bool <- equal c, 21/ctrl-u
     break-unless delete-to-start-of-line?
     <delete-to-start-of-line-begin>
-    deleted-cells:address:duplex-list:character <- delete-to-start-of-line editor
+    deleted-cells:&:duplex-list:char <- delete-to-start-of-line editor
     <delete-to-start-of-line-end>
     go-render? <- copy 1/true
     return
   }
 ]
 
-def delete-to-start-of-line editor:address:editor-data -> result:address:duplex-list:character, editor:address:editor-data [
+def delete-to-start-of-line editor:&:editor-data -> result:&:duplex-list:char, editor:&:editor-data [
   local-scope
   load-ingredients
   # compute range to delete
-  init:address:duplex-list:character <- get *editor, data:offset
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  start:address:duplex-list:character <- copy before-cursor
-  end:address:duplex-list:character <- next before-cursor
+  init:&:duplex-list:char <- get *editor, data:offset
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  start:&:duplex-list:char <- copy before-cursor
+  end:&:duplex-list:char <- next before-cursor
   {
-    at-start-of-text?:boolean <- equal start, init
+    at-start-of-text?:bool <- equal start, init
     break-if at-start-of-text?
-    curr:character <- get *start, value:offset
-    at-start-of-line?:boolean <- equal curr, 10/newline
+    curr:char <- get *start, value:offset
+    at-start-of-line?:bool <- equal curr, 10/newline
     break-if at-start-of-line?
     start <- prev start
     assert start, [delete-to-start-of-line tried to move before start of text]
     loop
   }
   # snip it out
-  result:address:duplex-list:character <- next start
+  result:&:duplex-list:char <- next start
   remove-between start, end
   # adjust cursor
   before-cursor <- copy start
   *editor <- put *editor, before-cursor:offset, before-cursor
-  left:number <- get *editor, left:offset
+  left:num <- get *editor, left:offset
   *editor <- put *editor, cursor-column:offset, left
 ]
 
@@ -1684,14 +1684,14 @@ scenario editor-deletes-to-start-of-line-with-ctrl-u-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start on first line (no newline before), press ctrl-u
   assume-console [
     left-click 1, 2
     press ctrl-u
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to start of line
   screen-should-contain [
@@ -1707,14 +1707,14 @@ scenario editor-deletes-to-start-of-line-with-ctrl-u-3 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start past end of line, press ctrl-u
   assume-console [
     left-click 1, 3
     press ctrl-u
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to start of line
   screen-should-contain [
@@ -1730,14 +1730,14 @@ scenario editor-deletes-to-start-of-final-line-with-ctrl-u [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start past end of final line, press ctrl-u
   assume-console [
     left-click 2, 3
     press ctrl-u
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to start of line
   screen-should-contain [
@@ -1755,14 +1755,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start on first line, press ctrl-k
   assume-console [
     left-click 1, 1
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to end of line
   screen-should-contain [
@@ -1776,27 +1776,27 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k [
 
 after <handle-special-character> [
   {
-    delete-to-end-of-line?:boolean <- equal c, 11/ctrl-k
+    delete-to-end-of-line?:bool <- equal c, 11/ctrl-k
     break-unless delete-to-end-of-line?
     <delete-to-end-of-line-begin>
-    deleted-cells:address:duplex-list:character <- delete-to-end-of-line editor
+    deleted-cells:&:duplex-list:char <- delete-to-end-of-line editor
     <delete-to-end-of-line-end>
     go-render? <- copy 1/true
     return
   }
 ]
 
-def delete-to-end-of-line editor:address:editor-data -> result:address:duplex-list:character, editor:address:editor-data [
+def delete-to-end-of-line editor:&:editor-data -> result:&:duplex-list:char, editor:&:editor-data [
   local-scope
   load-ingredients
   # compute range to delete
-  start:address:duplex-list:character <- get *editor, before-cursor:offset
-  end:address:duplex-list:character <- next start
+  start:&:duplex-list:char <- get *editor, before-cursor:offset
+  end:&:duplex-list:char <- next start
   {
-    at-end-of-text?:boolean <- equal end, 0/null
+    at-end-of-text?:bool <- equal end, 0/null
     break-if at-end-of-text?
-    curr:character <- get *end, value:offset
-    at-end-of-line?:boolean <- equal curr, 10/newline
+    curr:char <- get *end, value:offset
+    at-end-of-line?:bool <- equal curr, 10/newline
     break-if at-end-of-line?
     end <- next end
     loop
@@ -1810,14 +1810,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k-2 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start on second line (no newline after), press ctrl-k
   assume-console [
     left-click 2, 1
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes to end of line
   screen-should-contain [
@@ -1833,14 +1833,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k-3 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start at end of line
   assume-console [
     left-click 1, 2
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes just last character
   screen-should-contain [
@@ -1856,14 +1856,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k-4 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start past end of line
   assume-console [
     left-click 1, 3
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes nothing
   screen-should-contain [
@@ -1879,14 +1879,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k-5 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start at end of text
   assume-console [
     left-click 2, 2
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes just the final character
   screen-should-contain [
@@ -1902,14 +1902,14 @@ scenario editor-deletes-to-end-of-line-with-ctrl-k-6 [
   assume-screen 10/width, 5/height
   1:text <- new [123
 456]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   # start past end of text
   assume-console [
     left-click 2, 3
     press ctrl-k
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # cursor deletes nothing
   screen-should-contain [
@@ -1931,7 +1931,7 @@ scenario editor-can-scroll-down-using-arrow-keys [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -1944,7 +1944,7 @@ d]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen slides by one line
   screen-should-contain [
@@ -1957,14 +1957,14 @@ d]
 
 after <scroll-down> [
   trace 10, [app], [scroll down]
-  top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  max:number <- subtract right, left
-  old-top:address:duplex-list:character <- copy top-of-screen
+  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  max:num <- subtract right, left
+  old-top:&:duplex-list:char <- copy top-of-screen
   top-of-screen <- before-start-of-next-line top-of-screen, max
   *editor <- put *editor, top-of-screen:offset, top-of-screen
-  no-movement?:boolean <- equal old-top, top-of-screen
+  no-movement?:bool <- equal old-top, top-of-screen
   go-render? <- copy 0/false
   return-if no-movement?
 ]
@@ -1972,25 +1972,25 @@ after <scroll-down> [
 # takes a pointer into the doubly-linked list, scans ahead at most 'max'
 # positions until the next newline
 # beware: never return null pointer.
-def before-start-of-next-line original:address:duplex-list:character, max:number -> curr:address:duplex-list:character [
+def before-start-of-next-line original:&:duplex-list:char, max:num -> curr:&:duplex-list:char [
   local-scope
   load-ingredients
-  count:number <- copy 0
-  curr:address:duplex-list:character <- copy original
+  count:num <- copy 0
+  curr:&:duplex-list:char <- copy original
   # skip the initial newline if it exists
   {
-    c:character <- get *curr, value:offset
-    at-newline?:boolean <- equal c, 10/newline
+    c:char <- get *curr, value:offset
+    at-newline?:bool <- equal c, 10/newline
     break-unless at-newline?
     curr <- next curr
     count <- add count, 1
   }
   {
     return-unless curr, original
-    done?:boolean <- greater-or-equal count, max
+    done?:bool <- greater-or-equal count, max
     break-if done?
-    c:character <- get *curr, value:offset
-    at-newline?:boolean <- equal c, 10/newline
+    c:char <- get *curr, value:offset
+    at-newline?:bool <- equal c, 10/newline
     break-if at-newline?
     curr <- next curr
     count <- add count, 1
@@ -2009,7 +2009,7 @@ scenario editor-scrolls-down-past-wrapped-line-using-arrow-keys [
 g
 h
 i]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   screen-should-contain [
     .          .
     .abcd↩     .
@@ -2022,7 +2022,7 @@ i]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2041,14 +2041,14 @@ scenario editor-scrolls-down-past-wrapped-line-using-arrow-keys-2 [
 k
 l
 m]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at last line, then try to move further down
   assume-console [
     left-click 3, 0
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line containing a wrap icon
   screen-should-contain [
@@ -2062,7 +2062,7 @@ m]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2080,16 +2080,16 @@ scenario editor-scrolls-down-when-line-wraps [
   1:text <- new [a
 b
 cdef]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at end, type a character
   assume-console [
     left-click 3, 4
     type [g]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen scrolls
   screen-should-contain [
@@ -2110,16 +2110,16 @@ scenario editor-scrolls-down-on-newline [
   1:text <- new [a
 b
 c]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   assume-console [
     left-click 3, 4
     type [
 ]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen scrolls
   screen-should-contain [
@@ -2141,16 +2141,16 @@ scenario editor-scrolls-down-on-right-arrow [
   1:text <- new [a
 b
 cdefgh]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at end of screen and try to move right
   assume-console [
     left-click 3, 3
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen scrolls
   screen-should-contain [
@@ -2173,16 +2173,16 @@ scenario editor-scrolls-down-on-right-arrow-2 [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at end of screen and try to move right
   assume-console [
     left-click 3, 3
     press right-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen scrolls
   screen-should-contain [
@@ -2201,8 +2201,8 @@ scenario editor-scrolls-at-end-on-down-arrow [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 de]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   $clear-trace
   # try to move down past end of text
   assume-console [
@@ -2210,9 +2210,9 @@ de]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen should scroll, moving cursor to end of text
   memory-should-contain [
@@ -2223,7 +2223,7 @@ de]
     type [0]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2238,9 +2238,9 @@ de]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen stops scrolling because cursor is already at top
   memory-should-contain [
@@ -2252,7 +2252,7 @@ de]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2273,7 +2273,7 @@ d
 e
 f
 g]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # scroll down one page and one line
   assume-console [
     press page-down
@@ -2281,7 +2281,7 @@ g]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen scrolls down 3 lines
   screen-should-contain [
@@ -2302,7 +2302,7 @@ scenario editor-can-scroll-up-using-arrow-keys [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -2315,7 +2315,7 @@ d]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen slides by one line
   screen-should-contain [
@@ -2328,11 +2328,11 @@ d]
 
 after <scroll-up> [
   trace 10, [app], [scroll up]
-  top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-  old-top:address:duplex-list:character <- copy top-of-screen
+  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+  old-top:&:duplex-list:char <- copy top-of-screen
   top-of-screen <- before-previous-line top-of-screen, editor
   *editor <- put *editor, top-of-screen:offset, top-of-screen
-  no-movement?:boolean <- equal old-top, top-of-screen
+  no-movement?:bool <- equal old-top, top-of-screen
   go-render? <- copy 0/false
   return-if no-movement?
 ]
@@ -2340,39 +2340,39 @@ after <scroll-up> [
 # takes a pointer into the doubly-linked list, scans back to before start of
 # previous *wrapped* line
 # beware: never return null pointer
-def before-previous-line in:address:duplex-list:character, editor:address:editor-data -> out:address:duplex-list:character [
+def before-previous-line in:&:duplex-list:char, editor:&:editor-data -> out:&:duplex-list:char [
   local-scope
   load-ingredients
-  curr:address:duplex-list:character <- copy in
-  c:character <- get *curr, value:offset
+  curr:&:duplex-list:char <- copy in
+  c:char <- get *curr, value:offset
   # compute max, number of characters to skip
   #   1 + len%(width-1)
   #   except rotate second term to vary from 1 to width-1 rather than 0 to width-2
-  left:number <- get *editor, left:offset
-  right:number <- get *editor, right:offset
-  max-line-length:number <- subtract right, left, -1/exclusive-right, 1/wrap-icon
-  sentinel:address:duplex-list:character <- get *editor, data:offset
-  len:number <- previous-line-length curr, sentinel
+  left:num <- get *editor, left:offset
+  right:num <- get *editor, right:offset
+  max-line-length:num <- subtract right, left, -1/exclusive-right, 1/wrap-icon
+  sentinel:&:duplex-list:char <- get *editor, data:offset
+  len:num <- previous-line-length curr, sentinel
   {
     break-if len
     # empty line; just skip this newline
-    prev:address:duplex-list:character <- prev curr
+    prev:&:duplex-list:char <- prev curr
     return-unless prev, curr
     return prev
   }
-  _, max:number <- divide-with-remainder len, max-line-length
+  _, max:num <- divide-with-remainder len, max-line-length
   # remainder 0 => scan one width-worth
   {
     break-if max
     max <- copy max-line-length
   }
   max <- add max, 1
-  count:number <- copy 0
+  count:num <- copy 0
   # skip 'max' characters
   {
-    done?:boolean <- greater-or-equal count, max
+    done?:bool <- greater-or-equal count, max
     break-if done?
-    prev:address:duplex-list:character <- prev curr
+    prev:&:duplex-list:char <- prev curr
     break-unless prev
     curr <- copy prev
     count <- add count, 1
@@ -2390,7 +2390,7 @@ scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys [
 g
 h
 i]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   screen-should-contain [
     .          .
     .abcd↩     .
@@ -2402,7 +2402,7 @@ i]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2415,7 +2415,7 @@ i]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2434,13 +2434,13 @@ scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys-2 [
 k
 l
 m]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at top of second page
   assume-console [
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2454,7 +2454,7 @@ m]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2469,7 +2469,7 @@ m]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2484,7 +2484,7 @@ m]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2507,7 +2507,7 @@ scenario editor-scrolls-up-past-wrapped-line-using-arrow-keys-3 [
 g
 h
 i]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 6/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 6/right
   screen-should-contain [
     .          .
     .abcde↩    .
@@ -2519,7 +2519,7 @@ i]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2532,7 +2532,7 @@ i]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows partial wrapped line
   screen-should-contain [
@@ -2553,12 +2553,12 @@ b
 c
 d
 e]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 6/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 6/right
   assume-console [
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2570,7 +2570,7 @@ e]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2582,7 +2582,7 @@ e]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2601,13 +2601,13 @@ b
 c
 d
 e]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at top of second page
   assume-console [
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .     .
@@ -2620,9 +2620,9 @@ e]
     press left-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen scrolls
   screen-should-contain [
@@ -2645,7 +2645,7 @@ scenario editor-can-scroll-up-to-start-of-file [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -2660,7 +2660,7 @@ d]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen slides by one line
   screen-should-contain [
@@ -2674,7 +2674,7 @@ d]
     press up-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen remains unchanged
   screen-should-contain [
@@ -2693,7 +2693,7 @@ scenario editor-can-scroll [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -2705,7 +2705,7 @@ d]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows next page
   screen-should-contain [
@@ -2718,15 +2718,15 @@ d]
 
 after <handle-special-character> [
   {
-    page-down?:boolean <- equal c, 6/ctrl-f
+    page-down?:bool <- equal c, 6/ctrl-f
     break-unless page-down?
-    old-top:address:duplex-list:character <- get *editor, top-of-screen:offset
+    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
     <move-cursor-begin>
     page-down editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
-    top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-    no-movement?:boolean <- equal top-of-screen, old-top
+    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+    no-movement?:bool <- equal top-of-screen, old-top
     go-render? <- not no-movement?
     return
   }
@@ -2734,15 +2734,15 @@ after <handle-special-character> [
 
 after <handle-special-key> [
   {
-    page-down?:boolean <- equal k, 65518/page-down
+    page-down?:bool <- equal k, 65518/page-down
     break-unless page-down?
-    old-top:address:duplex-list:character <- get *editor, top-of-screen:offset
+    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
     <move-cursor-begin>
     page-down editor
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
-    top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-    no-movement?:boolean <- equal top-of-screen, old-top
+    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+    no-movement?:bool <- equal top-of-screen, old-top
     go-render? <- not no-movement?
     return
   }
@@ -2750,21 +2750,21 @@ after <handle-special-key> [
 
 # page-down skips entire wrapped lines, so it can't scroll past lines
 # taking up the entire screen
-def page-down editor:address:editor-data -> editor:address:editor-data [
+def page-down editor:&:editor-data -> editor:&:editor-data [
   local-scope
   load-ingredients
   # if editor contents don't overflow screen, do nothing
-  bottom-of-screen:address:duplex-list:character <- get *editor, bottom-of-screen:offset
+  bottom-of-screen:&:duplex-list:char <- get *editor, bottom-of-screen:offset
   return-unless bottom-of-screen
   # if not, position cursor at final character
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  before-cursor:address:duplex-list:character <- prev bottom-of-screen
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  before-cursor:&:duplex-list:char <- prev bottom-of-screen
   *editor <- put *editor, before-cursor:offset, before-cursor
   # keep one line in common with previous page
   {
-    last:character <- get *before-cursor, value:offset
-    newline?:boolean <- equal last, 10/newline
-    break-unless newline?:boolean
+    last:char <- get *before-cursor, value:offset
+    newline?:bool <- equal last, 10/newline
+    break-unless newline?:bool
     before-cursor <- prev before-cursor
     *editor <- put *editor, before-cursor:offset, before-cursor
   }
@@ -2778,8 +2778,8 @@ scenario editor-does-not-scroll-past-end [
   assume-screen 10/width, 4/height
   1:text <- new [a
 b]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   screen-should-contain [
     .          .
     .a         .
@@ -2791,7 +2791,7 @@ b]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen remains unmodified
   screen-should-contain [
@@ -2810,7 +2810,7 @@ scenario editor-starts-next-page-at-start-of-wrapped-line [
 b
 cdefgh]
   # editor screen triggers wrap of last line
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   # some part of last line is not displayed
   screen-should-contain [
     .          .
@@ -2823,7 +2823,7 @@ cdefgh]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows entire wrapped line
   screen-should-contain [
@@ -2841,7 +2841,7 @@ scenario editor-starts-next-page-at-start-of-wrapped-line-2 [
   # and still has something left over
   1:text <- new [a
 bcdefgh]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   # some part of last line is not displayed
   screen-should-contain [
     .          .
@@ -2854,7 +2854,7 @@ bcdefgh]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows entire wrapped line
   screen-should-contain [
@@ -2873,7 +2873,7 @@ scenario editor-can-scroll-up [
 b
 c
 d]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -2885,7 +2885,7 @@ d]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows next page
   screen-should-contain [
@@ -2899,7 +2899,7 @@ d]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows original page again
   screen-should-contain [
@@ -2912,15 +2912,15 @@ d]
 
 after <handle-special-character> [
   {
-    page-up?:boolean <- equal c, 2/ctrl-b
+    page-up?:bool <- equal c, 2/ctrl-b
     break-unless page-up?
-    old-top:address:duplex-list:character <- get *editor, top-of-screen:offset
+    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
     <move-cursor-begin>
     editor <- page-up editor, screen-height
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
-    top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-    no-movement?:boolean <- equal top-of-screen, old-top
+    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+    no-movement?:bool <- equal top-of-screen, old-top
     go-render? <- not no-movement?
     return
   }
@@ -2928,31 +2928,31 @@ after <handle-special-character> [
 
 after <handle-special-key> [
   {
-    page-up?:boolean <- equal k, 65519/page-up
+    page-up?:bool <- equal k, 65519/page-up
     break-unless page-up?
-    old-top:address:duplex-list:character <- get *editor, top-of-screen:offset
+    old-top:&:duplex-list:char <- get *editor, top-of-screen:offset
     <move-cursor-begin>
     editor <- page-up editor, screen-height
-    undo-coalesce-tag:number <- copy 0/never
+    undo-coalesce-tag:num <- copy 0/never
     <move-cursor-end>
-    top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
-    no-movement?:boolean <- equal top-of-screen, old-top
+    top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
+    no-movement?:bool <- equal top-of-screen, old-top
     # don't bother re-rendering if nothing changed. todo: test this
     go-render? <- not no-movement?
     return
   }
 ]
 
-def page-up editor:address:editor-data, screen-height:number -> editor:address:editor-data [
+def page-up editor:&:editor-data, screen-height:num -> editor:&:editor-data [
   local-scope
   load-ingredients
-  max:number <- subtract screen-height, 1/menu-bar, 1/overlapping-line
-  count:number <- copy 0
-  top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
+  max:num <- subtract screen-height, 1/menu-bar, 1/overlapping-line
+  count:num <- copy 0
+  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
   {
-    done?:boolean <- greater-or-equal count, max
+    done?:bool <- greater-or-equal count, max
     break-if done?
-    prev:address:duplex-list:character <- before-previous-line top-of-screen, editor
+    prev:&:duplex-list:char <- before-previous-line top-of-screen, editor
     break-unless prev
     top-of-screen <- copy prev
     *editor <- put *editor, top-of-screen:offset, top-of-screen
@@ -2973,7 +2973,7 @@ e
 f
 g
 h]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   screen-should-contain [
     .          .
     .a         .
@@ -2986,7 +2986,7 @@ h]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows third page
   screen-should-contain [
@@ -3000,7 +3000,7 @@ h]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows second page
   screen-should-contain [
@@ -3014,7 +3014,7 @@ h]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows original page again
   screen-should-contain [
@@ -3040,7 +3040,7 @@ m
 n
 o]
   # editor screen triggers wrap of last line
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   # some part of last line is not displayed
   screen-should-contain [
     .          .
@@ -3057,7 +3057,7 @@ o]
     press down-arrow
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows entire wrapped line
   screen-should-contain [
@@ -3073,7 +3073,7 @@ o]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen resets
   screen-should-contain [
@@ -3093,7 +3093,7 @@ scenario editor-can-scroll-up-wrapped-lines-2 [
   # and still has something left over
   1:text <- new [a
 bcdefgh]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   # some part of last line is not displayed
   screen-should-contain [
     .          .
@@ -3106,7 +3106,7 @@ bcdefgh]
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen shows entire wrapped line
   screen-should-contain [
@@ -3120,7 +3120,7 @@ bcdefgh]
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # screen resets
   screen-should-contain [
@@ -3143,7 +3143,7 @@ fxx
 gxx
 hxx
 ]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   screen-should-contain [
     .          .
     .axx       .
@@ -3154,7 +3154,7 @@ hxx
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -3166,7 +3166,7 @@ hxx
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -3179,7 +3179,7 @@ hxx
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -3201,7 +3201,7 @@ exy
 fxy
 gxy
 ]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 4/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 4/right
   screen-should-contain [
     .          .
     .axy       .
@@ -3212,7 +3212,7 @@ gxy
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -3224,7 +3224,7 @@ gxy
     press page-down
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -3237,7 +3237,7 @@ gxy
     press page-up
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
diff --git a/edit/004-programming-environment.mu b/edit/004-programming-environment.mu
index 4f4c6e61..d16162ff 100644
--- a/edit/004-programming-environment.mu
+++ b/edit/004-programming-environment.mu
@@ -9,90 +9,90 @@ def! main [
   initial-recipe:text <- restore [recipes.mu]
   initial-sandbox:text <- new []
   hide-screen 0/screen
-  env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
+  env:&:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
   render-all 0/screen, env, render
   event-loop 0/screen, 0/console, env
   # never gets here
 ]
 
 container programming-environment-data [
-  recipes:address:editor-data
-  current-sandbox:address:editor-data
-  sandbox-in-focus?:boolean  # false => cursor in recipes; true => cursor in current-sandbox
+  recipes:&:editor-data
+  current-sandbox:&:editor-data
+  sandbox-in-focus?:bool  # false => cursor in recipes; true => cursor in current-sandbox
 ]
 
-def new-programming-environment screen:address:screen, initial-recipe-contents:text, initial-sandbox-contents:text -> result:address:programming-environment-data, screen:address:screen [
+def new-programming-environment screen:&:screen, initial-recipe-contents:text, initial-sandbox-contents:text -> result:&:programming-environment-data, screen:&:screen [
   local-scope
   load-ingredients
-  width:number <- screen-width screen
-  height:number <- screen-height screen
+  width:num <- screen-width screen
+  height:num <- screen-height screen
   # top menu
   result <- new programming-environment-data:type
   draw-horizontal screen, 0, 0/left, width, 32/space, 0/black, 238/grey
-  button-start:number <- subtract width, 20
-  button-on-screen?:boolean <- greater-or-equal button-start, 0
+  button-start:num <- subtract width, 20
+  button-on-screen?:bool <- greater-or-equal button-start, 0
   assert button-on-screen?, [screen too narrow for menu]
   screen <- move-cursor screen, 0/row, button-start
   print screen, [ run (F4) ], 255/white, 161/reddish
   # dotted line down the middle
-  divider:number, _ <- divide-with-remainder width, 2
+  divider:num, _ <- divide-with-remainder width, 2
   draw-vertical screen, divider, 1/top, height, 9482/vertical-dotted
   # recipe editor on the left
-  recipes:address:editor-data <- new-editor initial-recipe-contents, screen, 0/left, divider/right
+  recipes:&:editor-data <- new-editor initial-recipe-contents, screen, 0/left, divider/right
   # sandbox editor on the right
-  sandbox-left:number <- add divider, 1
-  current-sandbox:address:editor-data <- new-editor initial-sandbox-contents, screen, sandbox-left, width/right
+  sandbox-left:num <- add divider, 1
+  current-sandbox:&:editor-data <- new-editor initial-sandbox-contents, screen, sandbox-left, width/right
   *result <- put *result, recipes:offset, recipes
   *result <- put *result, current-sandbox:offset, current-sandbox
   *result <- put *result, sandbox-in-focus?:offset, 0/false
   <programming-environment-initialization>
 ]
 
-def event-loop screen:address:screen, console:address:console, env:address:programming-environment-data -> screen:address:screen, console:address:console, env:address:programming-environment-data [
+def event-loop screen:&:screen, console:&:console, env:&:programming-environment-data -> screen:&:screen, console:&:console, env:&:programming-environment-data [
   local-scope
   load-ingredients
-  recipes:address:editor-data <- get *env, recipes:offset
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  sandbox-in-focus?:boolean <- get *env, sandbox-in-focus?:offset
+  recipes:&:editor-data <- get *env, recipes:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  sandbox-in-focus?:bool <- get *env, sandbox-in-focus?:offset
   # if we fall behind we'll stop updating the screen, but then we have to
   # render the entire screen when we catch up.
   # todo: test this
-  render-all-on-no-more-events?:boolean <- copy 0/false
+  render-all-on-no-more-events?:bool <- copy 0/false
   {
     # looping over each (keyboard or touch) event as it occurs
     +next-event
-    e:event, console, found?:boolean, quit?:boolean <- read-event console
+    e:event, console, found?:bool, quit?:bool <- read-event console
     loop-unless found?
     break-if quit?  # only in tests
     trace 10, [app], [next-event]
     <handle-event>
     # check for global events that will trigger regardless of which editor has focus
     {
-      k:number, is-keycode?:boolean <- maybe-convert e:event, keycode:variant
+      k:num, is-keycode?:bool <- maybe-convert e:event, keycode:variant
       break-unless is-keycode?
       <global-keypress>
     }
     {
-      c:character, is-unicode?:boolean <- maybe-convert e:event, text:variant
+      c:char, is-unicode?:bool <- maybe-convert e:event, text:variant
       break-unless is-unicode?
       <global-type>
     }
     # 'touch' event - send to both sides, see what picks it up
     {
-      t:touch-event, is-touch?:boolean <- maybe-convert e:event, touch:variant
+      t:touch-event, is-touch?:bool <- maybe-convert e:event, touch:variant
       break-unless is-touch?
       # ignore all but 'left-click' events for now
       # todo: test this
-      touch-type:number <- get t, type:offset
-      is-left-click?:boolean <- equal touch-type, 65513/mouse-left
+      touch-type:num <- get t, type:offset
+      is-left-click?:bool <- equal touch-type, 65513/mouse-left
       loop-unless is-left-click?, +next-event:label
-      click-row:number <- get t, row:offset
-      click-column:number <- get t, column:offset
+      click-row:num <- get t, row:offset
+      click-column:num <- get t, column:offset
       # later exceptions for non-editor touches will go here
       <global-touch>
       # send to both editors
       _ <- move-cursor-in-editor screen, recipes, t
-      sandbox-in-focus?:boolean <- move-cursor-in-editor screen, current-sandbox, t
+      sandbox-in-focus?:bool <- move-cursor-in-editor screen, current-sandbox, t
       *env <- put *env, sandbox-in-focus?:offset, sandbox-in-focus?
       screen <- update-cursor screen, recipes, current-sandbox, sandbox-in-focus?, env
       loop +next-event:label
@@ -100,10 +100,10 @@ def event-loop screen:address:screen, console:address:console, env:address:progr
     # 'resize' event - redraw editor
     # todo: test this after supporting resize in assume-console
     {
-      r:resize-event, is-resize?:boolean <- maybe-convert e:event, resize:variant
+      r:resize-event, is-resize?:bool <- maybe-convert e:event, resize:variant
       break-unless is-resize?
       # if more events, we're still resizing; wait until we stop
-      more-events?:boolean <- has-more-events? console
+      more-events?:bool <- has-more-events? console
       {
         break-unless more-events?
         render-all-on-no-more-events? <- copy 1/true  # no rendering now, full rendering on some future event
@@ -119,13 +119,13 @@ def event-loop screen:address:screen, console:address:console, env:address:progr
     # if it's not global and not a touch event, send to appropriate editor
     {
       hide-screen screen
-      sandbox-in-focus?:boolean <- get *env, sandbox-in-focus?:offset
+      sandbox-in-focus?:bool <- get *env, sandbox-in-focus?:offset
       {
         break-if sandbox-in-focus?
-        screen, recipes, render?:boolean <- handle-keyboard-event screen, recipes, e:event
+        screen, recipes, render?:bool <- handle-keyboard-event screen, recipes, e:event
         # refresh screen only if no more events
         # if there are more events to process, wait for them to clear up, then make sure you render-all afterward.
-        more-events?:boolean <- has-more-events? console
+        more-events?:bool <- has-more-events? console
         {
           break-unless more-events?
           render-all-on-no-more-events? <- copy 1/true  # no rendering now, full rendering on some future event
@@ -150,10 +150,10 @@ def event-loop screen:address:screen, console:address:console, env:address:progr
       }
       {
         break-unless sandbox-in-focus?
-        screen, current-sandbox, render?:boolean <- handle-keyboard-event screen, current-sandbox, e:event
+        screen, current-sandbox, render?:bool <- handle-keyboard-event screen, current-sandbox, e:event
         # refresh screen only if no more events
         # if there are more events to process, wait for them to clear up, then make sure you render-all afterward.
-        more-events?:boolean <- has-more-events? console
+        more-events?:bool <- has-more-events? console
         {
           break-unless more-events?
           render-all-on-no-more-events? <- copy 1/true  # no rendering now, full rendering on some future event
@@ -184,24 +184,24 @@ def event-loop screen:address:screen, console:address:console, env:address:progr
   }
 ]
 
-def resize screen:address:screen, env:address:programming-environment-data -> env:address:programming-environment-data, screen:address:screen [
+def resize screen:&:screen, env:&:programming-environment-data -> env:&:programming-environment-data, screen:&:screen [
   local-scope
   load-ingredients
   clear-screen screen  # update screen dimensions
-  width:number <- screen-width screen
-  divider:number, _ <- divide-with-remainder width, 2
+  width:num <- screen-width screen
+  divider:num, _ <- divide-with-remainder width, 2
   # update recipe editor
-  recipes:address:editor-data <- get *env, recipes:offset
-  right:number <- subtract divider, 1
+  recipes:&:editor-data <- get *env, recipes:offset
+  right:num <- subtract divider, 1
   *recipes <- put *recipes, right:offset, right
   # reset cursor (later we'll try to preserve its position)
   *recipes <- put *recipes, cursor-row:offset, 1
   *recipes <- put *recipes, cursor-column:offset, 0
   # update sandbox editor
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  left:number <- add divider, 1
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  left:num <- add divider, 1
   *current-sandbox <- put *current-sandbox, left:offset, left
-  right:number <- subtract width, 1
+  right:num <- subtract width, 1
   *current-sandbox <- put *current-sandbox, right:offset, right
   # reset cursor (later we'll try to preserve its position)
   *current-sandbox <- put *current-sandbox, cursor-row:offset, 1
@@ -211,49 +211,49 @@ def resize screen:address:screen, env:address:programming-environment-data -> en
 # Variant of 'render' that updates cursor-row and cursor-column based on
 # before-cursor (rather than the other way around). If before-cursor moves
 # off-screen, it resets cursor-row and cursor-column.
-def render-without-moving-cursor screen:address:screen, editor:address:editor-data -> last-row:number, last-column:number, screen:address:screen, editor:address:editor-data [
+def render-without-moving-cursor screen:&:screen, editor:&:editor-data -> last-row:num, last-column:num, screen:&:screen, editor:&:editor-data [
   local-scope
   load-ingredients
   return-unless editor, 1/top, 0/left, screen/same-as-ingredient:0, editor/same-as-ingredient:1
-  left:number <- get *editor, left:offset
-  screen-height:number <- screen-height screen
-  right:number <- get *editor, right:offset
-  curr:address:duplex-list:character <- get *editor, top-of-screen:offset
-  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev
+  left:num <- get *editor, left:offset
+  screen-height:num <- screen-height screen
+  right:num <- get *editor, right:offset
+  curr:&:duplex-list:char <- get *editor, top-of-screen:offset
+  prev:&:duplex-list:char <- copy curr  # just in case curr becomes null and we can't compute prev
   curr <- next curr
   +render-loop-initialization
-  color:number <- copy 7/white
-  row:number <- copy 1/top
-  column:number <- copy left
+  color:num <- copy 7/white
+  row:num <- copy 1/top
+  column:num <- copy left
   # save before-cursor
-  old-before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
+  old-before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
   # initialze cursor-row/cursor-column/before-cursor to the top of the screen
   # by default
   *editor <- put *editor, cursor-row:offset, row
   *editor <- put *editor, cursor-column:offset, column
-  top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset
+  top-of-screen:&:duplex-list:char <- get *editor, top-of-screen:offset
   *editor <- put *editor, before-cursor:offset, top-of-screen
   screen <- move-cursor screen, row, column
   {
     +next-character
     break-unless curr
-    off-screen?:boolean <- greater-or-equal row, screen-height
+    off-screen?:bool <- greater-or-equal row, screen-height
     break-if off-screen?
     # if we find old-before-cursor still on the new resized screen, update
     # editor-data.cursor-row and editor-data.cursor-column based on
     # old-before-cursor
     {
-      at-cursor?:boolean <- equal old-before-cursor, prev
+      at-cursor?:bool <- equal old-before-cursor, prev
       break-unless at-cursor?
       *editor <- put *editor, cursor-row:offset, row
       *editor <- put *editor, cursor-column:offset, column
       *editor <- put *editor, before-cursor:offset, old-before-cursor
     }
-    c:character <- get *curr, value:offset
+    c:char <- get *curr, value:offset
     <character-c-received>
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c, 10/newline
+      newline?:bool <- equal c, 10/newline
       break-unless newline?
       # clear rest of line in this window
       clear-line-until screen, right
@@ -268,10 +268,10 @@ def render-without-moving-cursor screen:address:screen, editor:address:editor-da
     {
       # at right? wrap. even if there's only one more letter left; we need
       # room for clicking on the cursor after it.
-      at-right?:boolean <- equal column, right
+      at-right?:bool <- equal column, right
       break-unless at-right?
       # print wrap icon
-      wrap-icon:character <- copy 8617/loop-back-to-left
+      wrap-icon:char <- copy 8617/loop-back-to-left
       print screen, wrap-icon, 245/grey
       column <- copy left
       row <- add row, 1
@@ -298,7 +298,7 @@ scenario point-at-multiple-editors [
   # initialize both halves of screen
   1:text <- new [abc]
   2:text <- new [def]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # focus on both sides
   assume-console [
     left-click 1, 1
@@ -306,11 +306,11 @@ scenario point-at-multiple-editors [
   ]
   # check cursor column in each
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:address:editor-data <- get *3:address:programming-environment-data, recipes:offset
-    5:number <- get *4:address:editor-data, cursor-column:offset
-    6:address:editor-data <- get *3:address:programming-environment-data, current-sandbox:offset
-    7:number <- get *6:address:editor-data, cursor-column:offset
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:&:editor-data <- get *3:&:programming-environment-data, recipes:offset
+    5:num <- get *4:&:editor-data, cursor-column:offset
+    6:&:editor-data <- get *3:&:programming-environment-data, current-sandbox:offset
+    7:num <- get *6:&:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     5 <- 1
@@ -324,8 +324,8 @@ scenario edit-multiple-editors [
   # initialize both halves of screen
   1:text <- new [abc]
   2:text <- new [def]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # type one letter in each of them
   assume-console [
     left-click 1, 1
@@ -334,11 +334,11 @@ scenario edit-multiple-editors [
     type [1]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:address:editor-data <- get *3:address:programming-environment-data, recipes:offset
-    5:number <- get *4:address:editor-data, cursor-column:offset
-    6:address:editor-data <- get *3:address:programming-environment-data, current-sandbox:offset
-    7:number <- get *6:address:editor-data, cursor-column:offset
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:&:editor-data <- get *3:&:programming-environment-data, recipes:offset
+    5:num <- get *4:&:editor-data, cursor-column:offset
+    6:&:editor-data <- get *3:&:programming-environment-data, current-sandbox:offset
+    7:num <- get *6:&:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .           run (F4)           .  # this line has a different background, but we don't test that yet
@@ -352,8 +352,8 @@ scenario edit-multiple-editors [
   ]
   # show the cursor at the right window
   run [
-    8:character/cursor <- copy 9251/␣
-    print screen:address:screen, 8:character/cursor
+    8:char/cursor <- copy 9251/␣
+    print screen:&:screen, 8:char/cursor
   ]
   screen-should-contain [
     .           run (F4)           .
@@ -369,8 +369,8 @@ scenario multiple-editors-cover-only-their-own-areas [
   run [
     1:text <- new [abc]
     2:text <- new [def]
-    3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-    render-all screen, 3:address:programming-environment-data, render
+    3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+    render-all screen, 3:&:programming-environment-data, render
   ]
   # divider isn't messed up
   screen-should-contain [
@@ -387,14 +387,14 @@ scenario editor-in-focus-keeps-cursor [
   assume-screen 30/width, 5/height
   1:text <- new [abc]
   2:text <- new [def]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # initialize programming environment and highlight cursor
   assume-console []
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # is cursor at the right place?
   screen-should-contain [
@@ -408,9 +408,9 @@ scenario editor-in-focus-keeps-cursor [
     type [z]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # cursor should still be right
   screen-should-contain [
@@ -428,8 +428,8 @@ scenario backspace-in-sandbox-editor-joins-lines [
   1:text <- new []
   2:text <- new [abc
 def]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   screen-should-contain [
     .           run (F4)           .
     .               ┊abc           .
@@ -443,9 +443,9 @@ def]
     press backspace
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # cursor moves to end of old line
   screen-should-contain [
@@ -456,47 +456,47 @@ def]
   ]
 ]
 
-def render-all screen:address:screen, env:address:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:address:screen, env:address:programming-environment-data [
+def render-all screen:&:screen, env:&:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:&:screen, env:&:programming-environment-data [
   local-scope
   load-ingredients
   trace 10, [app], [render all]
   hide-screen screen
   # top menu
   trace 11, [app], [render top menu]
-  width:number <- screen-width screen
+  width:num <- screen-width screen
   draw-horizontal screen, 0, 0/left, width, 32/space, 0/black, 238/grey
-  button-start:number <- subtract width, 20
-  button-on-screen?:boolean <- greater-or-equal button-start, 0
+  button-start:num <- subtract width, 20
+  button-on-screen?:bool <- greater-or-equal button-start, 0
   assert button-on-screen?, [screen too narrow for menu]
   screen <- move-cursor screen, 0/row, button-start
   print screen, [ run (F4) ], 255/white, 161/reddish
   # dotted line down the middle
   trace 11, [app], [render divider]
-  divider:number, _ <- divide-with-remainder width, 2
-  height:number <- screen-height screen
+  divider:num, _ <- divide-with-remainder width, 2
+  height:num <- screen-height screen
   draw-vertical screen, divider, 1/top, height, 9482/vertical-dotted
   #
   screen <- render-recipes screen, env, render-editor
   screen <- render-sandbox-side screen, env, render-editor
   <render-components-end>
   #
-  recipes:address:editor-data <- get *env, recipes:offset
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  sandbox-in-focus?:boolean <- get *env, sandbox-in-focus?:offset
+  recipes:&:editor-data <- get *env, recipes:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  sandbox-in-focus?:bool <- get *env, sandbox-in-focus?:offset
   screen <- update-cursor screen, recipes, current-sandbox, sandbox-in-focus?, env
   #
   show-screen screen
 ]
 
-def render-recipes screen:address:screen, env:address:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:address:screen, env:address:programming-environment-data [
+def render-recipes screen:&:screen, env:&:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:&:screen, env:&:programming-environment-data [
   local-scope
   load-ingredients
   trace 11, [app], [render recipes]
-  recipes:address:editor-data <- get *env, recipes:offset
+  recipes:&:editor-data <- get *env, recipes:offset
   # render recipes
-  left:number <- get *recipes, left:offset
-  right:number <- get *recipes, right:offset
-  row:number, column:number, screen <- call render-editor, screen, recipes
+  left:num <- get *recipes, left:offset
+  right:num <- get *recipes, right:offset
+  row:num, column:num, screen <- call render-editor, screen, recipes
   clear-line-until screen, right
   row <- add row, 1
   <render-recipe-components-end>
@@ -507,13 +507,13 @@ def render-recipes screen:address:screen, env:address:programming-environment-da
 ]
 
 # replaced in a later layer
-def render-sandbox-side screen:address:screen, env:address:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:address:screen, env:address:programming-environment-data [
+def render-sandbox-side screen:&:screen, env:&:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:&:screen, env:&:programming-environment-data [
   local-scope
   load-ingredients
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  left:number <- get *current-sandbox, left:offset
-  right:number <- get *current-sandbox, right:offset
-  row:number, column:number, screen, current-sandbox <- call render-editor, screen, current-sandbox
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  left:num <- get *current-sandbox, left:offset
+  right:num <- get *current-sandbox, right:offset
+  row:num, column:num, screen, current-sandbox <- call render-editor, screen, current-sandbox
   clear-line-until screen, right
   row <- add row, 1
   # draw solid line after code (you'll see why in later layers)
@@ -522,48 +522,48 @@ def render-sandbox-side screen:address:screen, env:address:programming-environme
   clear-screen-from screen, row, left, left, right
 ]
 
-def update-cursor screen:address:screen, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:boolean, env:address:programming-environment-data -> screen:address:screen [
+def update-cursor screen:&:screen, recipes:&:editor-data, current-sandbox:&:editor-data, sandbox-in-focus?:bool, env:&:programming-environment-data -> screen:&:screen [
   local-scope
   load-ingredients
   <update-cursor-special-cases>
   {
     break-if sandbox-in-focus?
-    cursor-row:number <- get *recipes, cursor-row:offset
-    cursor-column:number <- get *recipes, cursor-column:offset
+    cursor-row:num <- get *recipes, cursor-row:offset
+    cursor-column:num <- get *recipes, cursor-column:offset
   }
   {
     break-unless sandbox-in-focus?
-    cursor-row:number <- get *current-sandbox, cursor-row:offset
-    cursor-column:number <- get *current-sandbox, cursor-column:offset
+    cursor-row:num <- get *current-sandbox, cursor-row:offset
+    cursor-column:num <- get *current-sandbox, cursor-column:offset
   }
   screen <- move-cursor screen, cursor-row, cursor-column
 ]
 
 # like 'render' for texts, but with colorization for comments like in the editor
-def render-code screen:address:screen, s:text, left:number, right:number, row:number -> row:number, screen:address:screen [
+def render-code screen:&:screen, s:text, left:num, right:num, row:num -> row:num, screen:&:screen [
   local-scope
   load-ingredients
   return-unless s
-  color:number <- copy 7/white
-  column:number <- copy left
+  color:num <- copy 7/white
+  column:num <- copy left
   screen <- move-cursor screen, row, column
-  screen-height:number <- screen-height screen
-  i:number <- copy 0
-  len:number <- length *s
+  screen-height:num <- screen-height screen
+  i:num <- copy 0
+  len:num <- length *s
   {
     +next-character
-    done?:boolean <- greater-or-equal i, len
+    done?:bool <- greater-or-equal i, len
     break-if done?
     done? <- greater-or-equal row, screen-height
     break-if done?
-    c:character <- index *s, i
+    c:char <- index *s, i
     <character-c-received>  # only line different from render
     {
       # at right? wrap.
-      at-right?:boolean <- equal column, right
+      at-right?:bool <- equal column, right
       break-unless at-right?
       # print wrap icon
-      wrap-icon:character <- copy 8617/loop-back-to-left
+      wrap-icon:char <- copy 8617/loop-back-to-left
       print screen, wrap-icon, 245/grey
       column <- copy left
       row <- add row, 1
@@ -573,13 +573,13 @@ def render-code screen:address:screen, s:text, left:number, right:number, row:nu
     i <- add i, 1
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c, 10/newline
+      newline?:bool <- equal c, 10/newline
       break-unless newline?
       # clear rest of line in this window
       {
-        done?:boolean <- greater-than column, right
+        done?:bool <- greater-than column, right
         break-if done?
-        space:character <- copy 32/space
+        space:char <- copy 32/space
         print screen, space
         column <- add column, 1
         loop
@@ -593,7 +593,7 @@ def render-code screen:address:screen, s:text, left:number, right:number, row:nu
     column <- add column, 1
     loop
   }
-  was-at-left?:boolean <- equal column, left
+  was-at-left?:bool <- equal column, left
   clear-line-until screen, right
   {
     break-if was-at-left?
@@ -606,9 +606,9 @@ def render-code screen:address:screen, s:text, left:number, right:number, row:nu
 
 after <global-type> [
   {
-    redraw-screen?:boolean <- equal c, 12/ctrl-l
+    redraw-screen?:bool <- equal c, 12/ctrl-l
     break-unless redraw-screen?
-    screen <- render-all screen, env:address:programming-environment-data, render
+    screen <- render-all screen, env:&:programming-environment-data, render
     sync-screen screen
     loop +next-event:label
   }
@@ -619,9 +619,9 @@ after <global-type> [
 
 after <global-type> [
   {
-    switch-side?:boolean <- equal c, 14/ctrl-n
+    switch-side?:bool <- equal c, 14/ctrl-n
     break-unless switch-side?
-    sandbox-in-focus?:boolean <- get *env, sandbox-in-focus?:offset
+    sandbox-in-focus?:bool <- get *env, sandbox-in-focus?:offset
     sandbox-in-focus? <- not sandbox-in-focus?
     *env <- put *env, sandbox-in-focus?:offset, sandbox-in-focus?
     screen <- update-cursor screen, recipes, current-sandbox, sandbox-in-focus?, env
@@ -631,22 +631,22 @@ after <global-type> [
 
 ## helpers
 
-def draw-vertical screen:address:screen, col:number, y:number, bottom:number -> screen:address:screen [
+def draw-vertical screen:&:screen, col:num, y:num, bottom:num -> screen:&:screen [
   local-scope
   load-ingredients
-  style:character, style-found?:boolean <- next-ingredient
+  style:char, style-found?:bool <- next-ingredient
   {
     break-if style-found?
     style <- copy 9474/vertical
   }
-  color:number, color-found?:boolean <- next-ingredient
+  color:num, color-found?:bool <- next-ingredient
   {
     # default color to white
     break-if color-found?
     color <- copy 245/grey
   }
   {
-    continue?:boolean <- lesser-than y, bottom
+    continue?:bool <- lesser-than y, bottom
     break-unless continue?
     screen <- move-cursor screen, y, col
     print screen, style, color
diff --git a/edit/005-sandbox.mu b/edit/005-sandbox.mu
index 668a39f5..77d13238 100644
--- a/edit/005-sandbox.mu
+++ b/edit/005-sandbox.mu
@@ -13,7 +13,7 @@ def! main [
   initial-recipe:text <- restore [recipes.mu]
   initial-sandbox:text <- new []
   hide-screen 0/screen
-  env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
+  env:&:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
   env <- restore-sandboxes env
   render-all 0/screen, env, render
   event-loop 0/screen, 0/console, env
@@ -21,9 +21,9 @@ def! main [
 ]
 
 container programming-environment-data [
-  sandbox:address:sandbox-data  # list of sandboxes, from top to bottom
-  render-from:number
-  number-of-sandboxes:number
+  sandbox:&:sandbox-data  # list of sandboxes, from top to bottom
+  render-from:num
+  number-of-sandboxes:num
 ]
 
 after <programming-environment-initialization> [
@@ -35,10 +35,10 @@ container sandbox-data [
   response:text
   # coordinates to track clicks
   # constraint: will be 0 for sandboxes at positions before env.render-from
-  starting-row-on-screen:number
-  code-ending-row-on-screen:number  # past end of code
-  screen:address:screen  # prints in the sandbox go here
-  next-sandbox:address:sandbox-data
+  starting-row-on-screen:num
+  code-ending-row-on-screen:num  # past end of code
+  screen:&:screen  # prints in the sandbox go here
+  next-sandbox:&:sandbox-data
 ]
 
 scenario run-and-show-results [
@@ -48,13 +48,13 @@ scenario run-and-show-results [
   1:text <- new []
   # sandbox editor contains an instruction without storing outputs
   2:text <- new [divide-with-remainder 11, 3]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that screen prints the results
   screen-should-contain [
@@ -104,7 +104,7 @@ scenario run-and-show-results [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that screen prints the results
   screen-should-contain [
@@ -127,10 +127,10 @@ scenario run-and-show-results [
 after <global-keypress> [
   # F4? load all code and run all sandboxes.
   {
-    do-run?:boolean <- equal k, 65532/F4
+    do-run?:bool <- equal k, 65532/F4
     break-unless do-run?
     screen <- update-status screen, [running...       ], 245/grey
-    error?:boolean, env, screen <- run-sandboxes env, screen
+    error?:bool, env, screen <- run-sandboxes env, screen
     # F4 might update warnings and results on both sides
     screen <- render-all screen, env, render
     {
@@ -142,39 +142,39 @@ after <global-keypress> [
   }
 ]
 
-def run-sandboxes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [
+def run-sandboxes env:&:programming-environment-data, screen:&:screen -> errors-found?:bool, env:&:programming-environment-data, screen:&:screen [
   local-scope
   load-ingredients
-  errors-found?:boolean, env, screen <- update-recipes env, screen
+  errors-found?:bool, env, screen <- update-recipes env, screen
   return-if errors-found?
   # check contents of right editor (sandbox)
   <run-sandboxes-begin>
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   {
     sandbox-contents:text <- editor-contents current-sandbox
     break-unless sandbox-contents
     # if contents exist, first save them
     # run them and turn them into a new sandbox-data
-    new-sandbox:address:sandbox-data <- new sandbox-data:type
+    new-sandbox:&:sandbox-data <- new sandbox-data:type
     *new-sandbox <- put *new-sandbox, data:offset, sandbox-contents
     # push to head of sandbox list
-    dest:address:sandbox-data <- get *env, sandbox:offset
+    dest:&:sandbox-data <- get *env, sandbox:offset
     *new-sandbox <- put *new-sandbox, next-sandbox:offset, dest
     *env <- put *env, sandbox:offset, new-sandbox
     # update sandbox count
-    sandbox-count:number <- get *env, number-of-sandboxes:offset
+    sandbox-count:num <- get *env, number-of-sandboxes:offset
     sandbox-count <- add sandbox-count, 1
     *env <- put *env, number-of-sandboxes:offset, sandbox-count
     # clear sandbox editor
-    init:address:duplex-list:character <- push 167/§, 0/tail
+    init:&:duplex-list:char <- push 167/§, 0/tail
     *current-sandbox <- put *current-sandbox, data:offset, init
     *current-sandbox <- put *current-sandbox, top-of-screen:offset, init
   }
   # save all sandboxes before running, just in case we die when running
   save-sandboxes env
   # run all sandboxes
-  curr:address:sandbox-data <- get *env, sandbox:offset
-  idx:number <- copy 0
+  curr:&:sandbox-data <- get *env, sandbox:offset
+  idx:num <- copy 0
   {
     break-unless curr
     curr <- update-sandbox curr, env, idx
@@ -187,10 +187,10 @@ def run-sandboxes env:address:programming-environment-data, screen:address:scree
 
 # copy code from recipe editor, persist, load into mu
 # replaced in a later layer (whereupon errors-found? will actually be set)
-def update-recipes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [
+def update-recipes env:&:programming-environment-data, screen:&:screen -> errors-found?:bool, env:&:programming-environment-data, screen:&:screen [
   local-scope
   load-ingredients
-  recipes:address:editor-data <- get *env, recipes:offset
+  recipes:&:editor-data <- get *env, recipes:offset
   in:text <- editor-contents recipes
   save [recipes.mu], in  # newlayer: persistence
   reload in
@@ -198,30 +198,30 @@ def update-recipes env:address:programming-environment-data, screen:address:scre
 ]
 
 # replaced in a later layer
-def! update-sandbox sandbox:address:sandbox-data, env:address:programming-environment-data, idx:number -> sandbox:address:sandbox-data, env:address:programming-environment-data [
+def! update-sandbox sandbox:&:sandbox-data, env:&:programming-environment-data, idx:num -> sandbox:&:sandbox-data, env:&:programming-environment-data [
   local-scope
   load-ingredients
   data:text <- get *sandbox, data:offset
-  response:text, _, fake-screen:address:screen <- run-sandboxed data
+  response:text, _, fake-screen:&:screen <- run-sandboxed data
   *sandbox <- put *sandbox, response:offset, response
   *sandbox <- put *sandbox, screen:offset, fake-screen
 ]
 
-def update-status screen:address:screen, msg:text, color:number -> screen:address:screen [
+def update-status screen:&:screen, msg:text, color:num -> screen:&:screen [
   local-scope
   load-ingredients
   screen <- move-cursor screen, 0, 2
   screen <- print screen, msg, color, 238/grey/background
 ]
 
-def save-sandboxes env:address:programming-environment-data [
+def save-sandboxes env:&:programming-environment-data [
   local-scope
   load-ingredients
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   # first clear previous versions, in case we deleted some sandbox
   $system [rm lesson/[0-9]* >/dev/null 2>/dev/null]  # some shells can't handle '>&'
-  curr:address:sandbox-data <- get *env, sandbox:offset
-  idx:number <- copy 0
+  curr:&:sandbox-data <- get *env, sandbox:offset
+  idx:num <- copy 0
   {
     break-unless curr
     data:text <- get *curr, data:offset
@@ -234,18 +234,18 @@ def save-sandboxes env:address:programming-environment-data [
   }
 ]
 
-def! render-sandbox-side screen:address:screen, env:address:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:address:screen, env:address:programming-environment-data [
+def! render-sandbox-side screen:&:screen, env:&:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:&:screen, env:&:programming-environment-data [
   local-scope
   load-ingredients
   trace 11, [app], [render sandbox side]
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  row:number, column:number <- copy 1, 0
-  left:number <- get *current-sandbox, left:offset
-  right:number <- get *current-sandbox, right:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  row:num, column:num <- copy 1, 0
+  left:num <- get *current-sandbox, left:offset
+  right:num <- get *current-sandbox, right:offset
   # render sandbox editor
-  render-from:number <- get *env, render-from:offset
+  render-from:num <- get *env, render-from:offset
   {
-    render-current-sandbox?:boolean <- equal render-from, -1
+    render-current-sandbox?:bool <- equal render-from, -1
     break-unless render-current-sandbox?
     row, column, screen, current-sandbox <- call render-editor, screen, current-sandbox
     clear-screen-from screen, row, column, left, right
@@ -253,19 +253,19 @@ def! render-sandbox-side screen:address:screen, env:address:programming-environm
   }
   # render sandboxes
   draw-horizontal screen, row, left, right, 9473/horizontal-double
-  sandbox:address:sandbox-data <- get *env, sandbox:offset
+  sandbox:&:sandbox-data <- get *env, sandbox:offset
   row, screen <- render-sandboxes screen, sandbox, left, right, row, render-from
   clear-rest-of-screen screen, row, left, right
 ]
 
-def render-sandboxes screen:address:screen, sandbox:address:sandbox-data, left:number, right:number, row:number, render-from:number, idx:number -> row:number, screen:address:screen, sandbox:address:sandbox-data [
+def render-sandboxes screen:&:screen, sandbox:&:sandbox-data, left:num, right:num, row:num, render-from:num, idx:num -> row:num, screen:&:screen, sandbox:&:sandbox-data [
   local-scope
   load-ingredients
   return-unless sandbox
-  screen-height:number <- screen-height screen
-  at-bottom?:boolean <- greater-or-equal row, screen-height
-  return-if at-bottom?:boolean
-  hidden?:boolean <- lesser-than idx, render-from
+  screen-height:num <- screen-height screen
+  at-bottom?:bool <- greater-or-equal row, screen-height
+  return-if at-bottom?:bool
+  hidden?:bool <- lesser-than idx, render-from
   {
     break-if hidden?
     # render sandbox menu
@@ -284,8 +284,8 @@ def render-sandboxes screen:address:screen, sandbox:address:sandbox-data, left:n
     sandbox-response:text <- get *sandbox, response:offset
     <render-sandbox-results>
     {
-      sandbox-screen:address:screen <- get *sandbox, screen:offset
-      empty-screen?:boolean <- fake-screen-is-empty? sandbox-screen
+      sandbox-screen:&:screen <- get *sandbox, screen:offset
+      empty-screen?:bool <- fake-screen-is-empty? sandbox-screen
       break-if empty-screen?
       row, screen <- render-screen screen, sandbox-screen, left, right, row
     }
@@ -295,7 +295,7 @@ def render-sandboxes screen:address:screen, sandbox:address:sandbox-data, left:n
       row, screen <- render-text screen, sandbox-response, left, right, 245/grey, row
     }
     +render-sandbox-end
-    at-bottom?:boolean <- greater-or-equal row, screen-height
+    at-bottom?:bool <- greater-or-equal row, screen-height
     return-if at-bottom?
     # draw solid line after sandbox
     draw-horizontal screen, row, left, right, 9473/horizontal-double
@@ -308,28 +308,28 @@ def render-sandboxes screen:address:screen, sandbox:address:sandbox-data, left:n
     <end-render-sandbox-reset-hidden>
   }
   # draw next sandbox
-  next-sandbox:address:sandbox-data <- get *sandbox, next-sandbox:offset
-  next-idx:number <- add idx, 1
+  next-sandbox:&:sandbox-data <- get *sandbox, next-sandbox:offset
+  next-idx:num <- add idx, 1
   row, screen <- render-sandboxes screen, next-sandbox, left, right, row, render-from, next-idx
 ]
 
-def render-sandbox-menu screen:address:screen, sandbox-index:number, left:number, right:number -> screen:address:screen [
+def render-sandbox-menu screen:&:screen, sandbox-index:num, left:num, right:num -> screen:&:screen [
   local-scope
   load-ingredients
   move-cursor-to-column screen, left
-  edit-button-left:number, edit-button-right:number, copy-button-left:number, copy-button-right:number, delete-button-left:number <- sandbox-menu-columns left, right
+  edit-button-left:num, edit-button-right:num, copy-button-left:num, copy-button-right:num, delete-button-left:num <- sandbox-menu-columns left, right
   print screen, sandbox-index, 232/dark-grey, 245/grey
-  start-buttons:number <- subtract edit-button-left, 1
+  start-buttons:num <- subtract edit-button-left, 1
   clear-line-until screen, start-buttons, 245/grey
   print screen, [edit], 232/black, 94/background-orange
   clear-line-until screen, edit-button-right, 94/background-orange
-  _, col:number <- cursor-position screen
-  at-start-of-copy-button?:boolean <- equal col, copy-button-left
+  _, col:num <- cursor-position screen
+  at-start-of-copy-button?:bool <- equal col, copy-button-left
   assert at-start-of-copy-button?, [aaa]
   print screen, [copy], 232/black, 58/background-green
   clear-line-until screen, copy-button-right, 58/background-green
-  _, col:number <- cursor-position screen
-  at-start-of-delete-button?:boolean <- equal col, delete-button-left
+  _, col:num <- cursor-position screen
+  at-start-of-delete-button?:bool <- equal col, delete-button-left
   assert at-start-of-delete-button?, [bbb]
   print screen, [delete], 232/black, 52/background-red
   clear-line-until screen, right, 52/background-red
@@ -338,45 +338,45 @@ def render-sandbox-menu screen:address:screen, sandbox-index:number, left:number
 # divide up the menu bar for a sandbox into 3 segments, for edit/copy/delete buttons
 # delete-button-right == right
 # all left/right pairs are inclusive
-def sandbox-menu-columns left:number, right:number -> edit-button-left:number, edit-button-right:number, copy-button-left:number, copy-button-right:number, delete-button-left:number [
+def sandbox-menu-columns left:num, right:num -> edit-button-left:num, edit-button-right:num, copy-button-left:num, copy-button-right:num, delete-button-left:num [
   local-scope
   load-ingredients
-  start-buttons:number <- add left, 4/space-for-sandbox-index
-  buttons-space:number <- subtract right, start-buttons
-  button-width:number <- divide-with-remainder buttons-space, 3  # integer division
-  buttons-wide-enough?:boolean <- greater-or-equal button-width, 8
+  start-buttons:num <- add left, 4/space-for-sandbox-index
+  buttons-space:num <- subtract right, start-buttons
+  button-width:num <- divide-with-remainder buttons-space, 3  # integer division
+  buttons-wide-enough?:bool <- greater-or-equal button-width, 8
   assert buttons-wide-enough?, [sandbox must be at least 30 or so characters wide]
-  edit-button-left:number <- copy start-buttons
-  copy-button-left:number <- add start-buttons, button-width
-  edit-button-right:number <- subtract copy-button-left, 1
-  delete-button-left:number <- subtract right, button-width
-  copy-button-right:number <- subtract delete-button-left, 1
+  edit-button-left:num <- copy start-buttons
+  copy-button-left:num <- add start-buttons, button-width
+  edit-button-right:num <- subtract copy-button-left, 1
+  delete-button-left:num <- subtract right, button-width
+  copy-button-right:num <- subtract delete-button-left, 1
 ]
 
 # print a text 's' to 'editor' in 'color' starting at 'row'
 # clear rest of last line, move cursor to next line
-def render-text screen:address:screen, s:text, left:number, right:number, color:number, row:number -> row:number, screen:address:screen [
+def render-text screen:&:screen, s:text, left:num, right:num, color:num, row:num -> row:num, screen:&:screen [
   local-scope
   load-ingredients
   return-unless s
-  column:number <- copy left
+  column:num <- copy left
   screen <- move-cursor screen, row, column
-  screen-height:number <- screen-height screen
-  i:number <- copy 0
-  len:number <- length *s
+  screen-height:num <- screen-height screen
+  i:num <- copy 0
+  len:num <- length *s
   {
     +next-character
-    done?:boolean <- greater-or-equal i, len
+    done?:bool <- greater-or-equal i, len
     break-if done?
     done? <- greater-or-equal row, screen-height
     break-if done?
-    c:character <- index *s, i
+    c:char <- index *s, i
     {
       # at right? wrap.
-      at-right?:boolean <- equal column, right
+      at-right?:bool <- equal column, right
       break-unless at-right?
       # print wrap icon
-      wrap-icon:character <- copy 8617/loop-back-to-left
+      wrap-icon:char <- copy 8617/loop-back-to-left
       print screen, wrap-icon, 245/grey
       column <- copy left
       row <- add row, 1
@@ -386,13 +386,13 @@ def render-text screen:address:screen, s:text, left:number, right:number, color:
     i <- add i, 1
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c, 10/newline
+      newline?:bool <- equal c, 10/newline
       break-unless newline?
       # clear rest of line in this window
       {
-        done?:boolean <- greater-than column, right
+        done?:bool <- greater-than column, right
         break-if done?
-        space:character <- copy 32/space
+        space:char <- copy 32/space
         print screen, space
         column <- add column, 1
         loop
@@ -406,7 +406,7 @@ def render-text screen:address:screen, s:text, left:number, right:number, color:
     column <- add column, 1
     loop
   }
-  was-at-left?:boolean <- equal column, left
+  was-at-left?:bool <- equal column, left
   clear-line-until screen, right
   {
     break-if was-at-left?
@@ -416,13 +416,13 @@ def render-text screen:address:screen, s:text, left:number, right:number, color:
 ]
 
 # assumes programming environment has no sandboxes; restores them from previous session
-def restore-sandboxes env:address:programming-environment-data -> env:address:programming-environment-data [
+def restore-sandboxes env:&:programming-environment-data -> env:&:programming-environment-data [
   local-scope
   load-ingredients
   # read all scenarios, pushing them to end of a list of scenarios
-  idx:number <- copy 0
-  curr:address:sandbox-data <- copy 0
-  prev:address:sandbox-data <- copy 0
+  idx:num <- copy 0
+  curr:&:sandbox-data <- copy 0
+  prev:&:sandbox-data <- copy 0
   {
     filename:text <- to-text idx
     contents:text <- restore filename
@@ -450,7 +450,7 @@ def restore-sandboxes env:address:programming-environment-data -> env:address:pr
 
 # print the fake sandbox screen to 'screen' with appropriate delimiters
 # leave cursor at start of next line
-def render-screen screen:address:screen, sandbox-screen:address:screen, left:number, right:number, row:number -> row:number, screen:address:screen [
+def render-screen screen:&:screen, sandbox-screen:&:screen, left:num, right:num, row:num -> row:num, screen:&:screen [
   local-scope
   load-ingredients
   return-unless sandbox-screen
@@ -458,39 +458,39 @@ def render-screen screen:address:screen, sandbox-screen:address:screen, left:num
   row <- render-text screen, [screen:], left, right, 245/grey, row
   screen <- move-cursor screen, row, left
   # start printing sandbox-screen
-  column:number <- copy left
-  s-width:number <- screen-width sandbox-screen
-  s-height:number <- screen-height sandbox-screen
-  buf:address:array:screen-cell <- get *sandbox-screen, data:offset
-  stop-printing:number <- add left, s-width, 3
-  max-column:number <- min stop-printing, right
-  i:number <- copy 0
-  len:number <- length *buf
-  screen-height:number <- screen-height screen
+  column:num <- copy left
+  s-width:num <- screen-width sandbox-screen
+  s-height:num <- screen-height sandbox-screen
+  buf:&:@:screen-cell <- get *sandbox-screen, data:offset
+  stop-printing:num <- add left, s-width, 3
+  max-column:num <- min stop-printing, right
+  i:num <- copy 0
+  len:num <- length *buf
+  screen-height:num <- screen-height screen
   {
-    done?:boolean <- greater-or-equal i, len
+    done?:bool <- greater-or-equal i, len
     break-if done?
     done? <- greater-or-equal row, screen-height
     break-if done?
     column <- copy left
     screen <- move-cursor screen, row, column
     # initial leader for each row: two spaces and a '.'
-    space:character <- copy 32/space
+    space:char <- copy 32/space
     print screen, space, 245/grey
     print screen, space, 245/grey
-    full-stop:character <- copy 46/period
+    full-stop:char <- copy 46/period
     print screen, full-stop, 245/grey
     column <- add left, 3
     {
       # print row
-      row-done?:boolean <- greater-or-equal column, max-column
+      row-done?:bool <- greater-or-equal column, max-column
       break-if row-done?
       curr:screen-cell <- index *buf, i
-      c:character <- get curr, contents:offset
-      color:number <- get curr, color:offset
+      c:char <- get curr, contents:offset
+      color:num <- get curr, color:offset
       {
         # damp whites down to grey
-        white?:boolean <- equal color, 7/white
+        white?:bool <- equal color, 7/white
         break-unless white?
         color <- copy 245/grey
       }
@@ -504,7 +504,7 @@ def render-screen screen:address:screen, sandbox-screen:address:screen, left:num
     column <- add column, 1
     {
       # clear rest of current line
-      line-done?:boolean <- greater-than column, right
+      line-done?:bool <- greater-than column, right
       break-if line-done?
       print screen, space
       column <- add column, 1
@@ -522,23 +522,23 @@ scenario run-updates-results [
   1:text <- new [ 
 recipe foo [
 local-scope
-z:number <- add 2, 2
+z:num <- add 2, 2
 reply z
 ]]
   # sandbox editor contains an instruction without storing outputs
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .local-scope                                       ┊0   edit          copy            delete         .
-    .z:number <- add 2, 2                              ┊foo                                              .
+    .z:num <- add 2, 2                                 ┊foo                                              .
     .reply z                                           ┊4                                                .
     .]                                                 ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
@@ -552,7 +552,7 @@ reply z
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that screen updates the result on the right
   screen-should-contain [
@@ -560,7 +560,7 @@ reply z
     .                                                  ┊                                                 .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .local-scope                                       ┊0   edit          copy            delete         .
-    .z:number <- add 2, 3                              ┊foo                                              .
+    .z:num <- add 2, 3                                 ┊foo                                              .
     .reply z                                           ┊5                                                .
     .]                                                 ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
@@ -575,13 +575,13 @@ scenario run-instruction-manages-screen-per-sandbox [
   1:text <- new []
   # right editor contains an instruction
   2:text <- new [print-integer screen, 4]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editor
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that it prints a little toy screen
   screen-should-contain [
@@ -601,18 +601,18 @@ scenario run-instruction-manages-screen-per-sandbox [
   ]
 ]
 
-def editor-contents editor:address:editor-data -> result:text [
+def editor-contents editor:&:editor-data -> result:text [
   local-scope
   load-ingredients
-  buf:address:buffer <- new-buffer 80
-  curr:address:duplex-list:character <- get *editor, data:offset
+  buf:&:buffer <- new-buffer 80
+  curr:&:duplex-list:char <- get *editor, data:offset
   # skip § sentinel
   assert curr, [editor without data is illegal; must have at least a sentinel]
   curr <- next curr
   return-unless curr, 0
   {
     break-unless curr
-    c:character <- get *curr, value:offset
+    c:char <- get *curr, value:offset
     buf <- append buf, c
     curr <- next curr
     loop
@@ -623,15 +623,15 @@ def editor-contents editor:address:editor-data -> result:text [
 scenario editor-provides-edited-contents [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   assume-console [
     left-click 1, 2
     type [def]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:text <- editor-contents 2:address:editor-data
-    4:array:character <- copy *3:text
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:text <- editor-contents 2:&:editor-data
+    4:@:char <- copy *3:text
   ]
   memory-should-contain [
     4:array:character <- [abdefc]
@@ -644,13 +644,13 @@ scenario scrolling-down-past-bottom-of-recipe-editor [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:address:programming-environment-data <- new-programming-environment screen:address:screen, [], []
+  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     press enter
     press down-arrow
   ]
-  event-loop screen, console:address:console, env
+  event-loop screen, console:&:console, env
   # no scroll
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -665,16 +665,16 @@ scenario cursor-down-in-recipe-editor [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:address:programming-environment-data <- new-programming-environment screen:address:screen, [], []
+  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     press enter
     press up-arrow
     press down-arrow  # while cursor isn't at bottom
   ]
-  event-loop screen, console:address:console, env
-  cursor:character <- copy 9251/␣
-  print screen:address:screen, cursor
+  event-loop screen, console:&:console, env
+  cursor:char <- copy 9251/␣
+  print screen:&:screen, cursor
   # cursor moves back to bottom
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -689,7 +689,7 @@ scenario cursor-down-in-recipe-editor [
 # layers will add other stuff to the left side below the editor (error messages)
 
 container programming-environment-data [
-  recipe-bottom:number
+  recipe-bottom:num
 ]
 
 after <render-recipe-components-end> [
@@ -699,22 +699,22 @@ after <render-recipe-components-end> [
 after <global-keypress> [
   {
     break-if sandbox-in-focus?
-    down-arrow?:boolean <- equal k, 65516/down-arrow
+    down-arrow?:bool <- equal k, 65516/down-arrow
     break-unless down-arrow?
-    recipe-editor:address:editor-data <- get *env, recipes:offset
-    recipe-cursor-row:number <- get *recipe-editor, cursor-row:offset
-    recipe-editor-bottom:number <- get *recipe-editor, bottom:offset
-    at-bottom-of-editor?:boolean <- greater-or-equal recipe-cursor-row, recipe-editor-bottom
+    recipe-editor:&:editor-data <- get *env, recipes:offset
+    recipe-cursor-row:num <- get *recipe-editor, cursor-row:offset
+    recipe-editor-bottom:num <- get *recipe-editor, bottom:offset
+    at-bottom-of-editor?:bool <- greater-or-equal recipe-cursor-row, recipe-editor-bottom
     break-unless at-bottom-of-editor?
-    more-to-scroll?:boolean <- more-to-scroll? env, screen
+    more-to-scroll?:bool <- more-to-scroll? env, screen
     break-if more-to-scroll?
     loop +next-event:label
   }
   {
     break-if sandbox-in-focus?
-    page-down?:boolean <- equal k, 65518/page-down
+    page-down?:bool <- equal k, 65518/page-down
     break-unless page-down?
-    more-to-scroll?:boolean <- more-to-scroll? env, screen
+    more-to-scroll?:bool <- more-to-scroll? env, screen
     break-if more-to-scroll?
     loop +next-event:label
   }
@@ -723,19 +723,19 @@ after <global-keypress> [
 after <global-type> [
   {
     break-if sandbox-in-focus?
-    page-down?:boolean <- equal k, 6/ctrl-f
+    page-down?:bool <- equal k, 6/ctrl-f
     break-unless page-down?
-    more-to-scroll?:boolean <- more-to-scroll? env, screen
+    more-to-scroll?:bool <- more-to-scroll? env, screen
     break-if more-to-scroll?
     loop +next-event:label
   }
 ]
 
-def more-to-scroll? env:address:programming-environment-data, screen:address:screen -> result:boolean [
+def more-to-scroll? env:&:programming-environment-data, screen:&:screen -> result:bool [
   local-scope
   load-ingredients
-  recipe-bottom:number <- get *env, recipe-bottom:offset
-  height:number <- screen-height screen
+  recipe-bottom:num <- get *env, recipe-bottom:offset
+  height:num <- screen-height screen
   result <- greater-or-equal recipe-bottom, height
 ]
 
@@ -743,7 +743,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor-2 [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:address:programming-environment-data <- new-programming-environment screen:address:screen, [], []
+  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     # add a line
@@ -753,7 +753,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor-2 [
     # try to scroll
     press page-down  # or ctrl-f
   ]
-  event-loop screen, console:address:console, env
+  event-loop screen, console:&:console, env
   # no scroll, and cursor remains at top line
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -768,7 +768,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor-3 [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:address:programming-environment-data <- new-programming-environment screen:address:screen, [], [ab
+  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], [ab
 cd]
   render-all screen, env, render
   assume-console [
@@ -779,9 +779,9 @@ cd]
     # move cursor
     press down-arrow
   ]
-  event-loop screen, console:address:console, env
-  cursor:character <- copy 9251/␣
-  print screen:address:screen, cursor
+  event-loop screen, console:&:console, env
+  cursor:char <- copy 9251/␣
+  print screen:&:screen, cursor
   # no scroll on recipe side, cursor moves on sandbox side
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -800,13 +800,13 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
   # initialize sandbox side
   1:text <- new []
   2:text <- new [add 2, 2]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   assume-console [
     # create a sandbox
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -820,9 +820,9 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox
@@ -838,9 +838,9 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
     press page-up
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # sandbox editor displays again, cursor is in editor
   screen-should-contain [
@@ -856,16 +856,16 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
 after <global-keypress> [
   {
     break-unless sandbox-in-focus?
-    page-down?:boolean <- equal k, 65518/page-down
+    page-down?:bool <- equal k, 65518/page-down
     break-unless page-down?
-    sandbox:address:sandbox-data <- get *env, sandbox:offset
+    sandbox:&:sandbox-data <- get *env, sandbox:offset
     break-unless sandbox
     # slide down if possible
     {
-      render-from:number <- get *env, render-from:offset
-      number-of-sandboxes:number <- get *env, number-of-sandboxes:offset
-      max:number <- subtract number-of-sandboxes, 1
-      at-end?:boolean <- greater-or-equal render-from, max
+      render-from:num <- get *env, render-from:offset
+      number-of-sandboxes:num <- get *env, number-of-sandboxes:offset
+      max:num <- subtract number-of-sandboxes, 1
+      at-end?:bool <- greater-or-equal render-from, max
       jump-if at-end?, +finish-event:label  # render nothing
       render-from <- add render-from, 1
       *env <- put *env, render-from:offset, render-from
@@ -881,10 +881,10 @@ after <global-keypress> [
 after <update-cursor-special-cases> [
   {
     break-unless sandbox-in-focus?
-    render-from:number <- get *env, render-from:offset
-    scrolling?:boolean <- greater-or-equal render-from, 0
+    render-from:num <- get *env, render-from:offset
+    scrolling?:bool <- greater-or-equal render-from, 0
     break-unless scrolling?
-    cursor-column:number <- get *current-sandbox, left:offset
+    cursor-column:num <- get *current-sandbox, left:offset
     screen <- move-cursor screen, 2/row, cursor-column  # highlighted sandbox will always start at row 2
     return
   }
@@ -894,10 +894,10 @@ after <update-cursor-special-cases> [
 after <global-keypress> [
   {
     break-unless sandbox-in-focus?
-    page-up?:boolean <- equal k, 65519/page-up
+    page-up?:bool <- equal k, 65519/page-up
     break-unless page-up?
-    render-from:number <- get *env, render-from:offset
-    at-beginning?:boolean <- equal render-from, -1
+    render-from:num <- get *env, render-from:offset
+    at-beginning?:bool <- equal render-from, -1
     break-if at-beginning?
     render-from <- subtract render-from, 1
     *env <- put *env, render-from:offset, render-from
@@ -910,15 +910,15 @@ after <global-keypress> [
 
 # sandbox belonging to 'env' whose next-sandbox is 'in'
 # return 0 if there's no such sandbox, either because 'in' doesn't exist in 'env', or because it's the first sandbox
-def previous-sandbox env:address:programming-environment-data, in:address:sandbox-data -> out:address:sandbox-data [
+def previous-sandbox env:&:programming-environment-data, in:&:sandbox-data -> out:&:sandbox-data [
   local-scope
   load-ingredients
-  curr:address:sandbox-data <- get *env, sandbox:offset
+  curr:&:sandbox-data <- get *env, sandbox:offset
   return-unless curr, 0/nil
-  next:address:sandbox-data <- get *curr, next-sandbox:offset
+  next:&:sandbox-data <- get *curr, next-sandbox:offset
   {
     return-unless next, 0/nil
-    found?:boolean <- equal next, in
+    found?:bool <- equal next, in
     break-if found?
     curr <- copy next
     next <- get *curr, next-sandbox:offset
@@ -935,20 +935,20 @@ scenario scrolling-down-on-recipe-side [
 ]
   # create a sandbox
   2:text <- new [add 2, 2]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   # hit 'down' in recipe editor
   assume-console [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # cursor moves down on recipe side
   screen-should-contain [
@@ -966,8 +966,8 @@ scenario scrolling-through-multiple-sandboxes [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes
   assume-console [
     press ctrl-n
@@ -976,9 +976,9 @@ scenario scrolling-through-multiple-sandboxes [
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-  4:character/cursor <- copy 9251/␣
-  print screen:address:screen, 4:character/cursor
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  4:char/cursor <- copy 9251/␣
+  print screen:&:screen, 4:char/cursor
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊␣                                                .
@@ -996,9 +996,9 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox
@@ -1018,7 +1018,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # just second sandbox displayed
   screen-should-contain [
@@ -1035,7 +1035,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # no change
   screen-should-contain [
@@ -1052,7 +1052,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # back to displaying both sandboxes without editor
   screen-should-contain [
@@ -1071,9 +1071,9 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # back to displaying both sandboxes as well as editor
   screen-should-contain [
@@ -1093,9 +1093,9 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   # no change
   screen-should-contain [
@@ -1118,15 +1118,15 @@ scenario scrolling-manages-sandbox-index-correctly [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create a sandbox
   assume-console [
     press ctrl-n
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -1142,7 +1142,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox
@@ -1160,7 +1160,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-up
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # back to displaying both sandboxes as well as editor
   screen-should-contain [
@@ -1178,7 +1178,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox
diff --git a/edit/006-sandbox-copy.mu b/edit/006-sandbox-copy.mu
index a08a1ec7..642e17c2 100644
--- a/edit/006-sandbox-copy.mu
+++ b/edit/006-sandbox-copy.mu
@@ -14,8 +14,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -31,7 +31,7 @@ recipe foo [
     left-click 3, 69
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # it copies into editor
   screen-should-contain [
@@ -49,7 +49,7 @@ recipe foo [
     type [0]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -76,8 +76,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -93,7 +93,7 @@ recipe foo [
     left-click 3, 84
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # it copies into editor
   screen-should-contain [
@@ -111,7 +111,7 @@ recipe foo [
     type [0]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -128,7 +128,7 @@ recipe foo [
 after <global-touch> [
   # support 'copy' button
   {
-    copy?:boolean <- should-attempt-copy? click-row, click-column, env
+    copy?:bool <- should-attempt-copy? click-row, click-column, env
     break-unless copy?
     copy?, env <- try-copy-sandbox click-row, env
     break-unless copy?
@@ -141,34 +141,34 @@ after <global-touch> [
 ]
 
 # some preconditions for attempting to copy a sandbox
-def should-attempt-copy? click-row:number, click-column:number, env:address:programming-environment-data -> result:boolean [
+def should-attempt-copy? click-row:num, click-column:num, env:&:programming-environment-data -> result:bool [
   local-scope
   load-ingredients
   # are we below the sandbox editor?
-  click-sandbox-area?:boolean <- click-on-sandbox-area? click-row, click-column, env
+  click-sandbox-area?:bool <- click-on-sandbox-area? click-row, click-column, env
   reply-unless click-sandbox-area?, 0/false
   # narrower, is the click in the columns spanning the 'copy' button?
-  first-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  first-sandbox:&:editor-data <- get *env, current-sandbox:offset
   assert first-sandbox, [!!]
-  sandbox-left-margin:number <- get *first-sandbox, left:offset
-  sandbox-right-margin:number <- get *first-sandbox, right:offset
-  _, _, copy-button-left:number, copy-button-right:number, _ <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
-  copy-button-vertical-area?:boolean <- within-range? click-column, copy-button-left, copy-button-right
+  sandbox-left-margin:num <- get *first-sandbox, left:offset
+  sandbox-right-margin:num <- get *first-sandbox, right:offset
+  _, _, copy-button-left:num, copy-button-right:num, _ <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
+  copy-button-vertical-area?:bool <- within-range? click-column, copy-button-left, copy-button-right
   reply-unless copy-button-vertical-area?, 0/false
   # finally, is sandbox editor empty?
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   result <- empty-editor? current-sandbox
 ]
 
-def try-copy-sandbox click-row:number, env:address:programming-environment-data -> clicked-on-copy-button?:boolean, env:address:programming-environment-data [
+def try-copy-sandbox click-row:num, env:&:programming-environment-data -> clicked-on-copy-button?:bool, env:&:programming-environment-data [
   local-scope
   load-ingredients
   # identify the sandbox to copy, if the click was actually on the 'copy' button
-  sandbox:address:sandbox-data <- find-sandbox env, click-row
+  sandbox:&:sandbox-data <- find-sandbox env, click-row
   return-unless sandbox, 0/false
   clicked-on-copy-button? <- copy 1/true
   text:text <- get *sandbox, data:offset
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   current-sandbox <- insert-text current-sandbox, text
   # reset scroll
   *env <- put *env, render-from:offset, -1
@@ -176,14 +176,14 @@ def try-copy-sandbox click-row:number, env:address:programming-environment-data
   *env <- put *env, sandbox-in-focus?:offset, 1/true
 ]
 
-def find-sandbox env:address:programming-environment-data, click-row:number -> result:address:sandbox-data [
+def find-sandbox env:&:programming-environment-data, click-row:num -> result:&:sandbox-data [
   local-scope
   load-ingredients
-  curr-sandbox:address:sandbox-data <- get *env, sandbox:offset
+  curr-sandbox:&:sandbox-data <- get *env, sandbox:offset
   {
     break-unless curr-sandbox
-    start:number <- get *curr-sandbox, starting-row-on-screen:offset
-    found?:boolean <- equal click-row, start
+    start:num <- get *curr-sandbox, starting-row-on-screen:offset
+    found?:bool <- equal click-row, start
     return-if found?, curr-sandbox
     curr-sandbox <- get *curr-sandbox, next-sandbox:offset
     loop
@@ -191,32 +191,32 @@ def find-sandbox env:address:programming-environment-data, click-row:number -> r
   return 0/not-found
 ]
 
-def click-on-sandbox-area? click-row:number, click-column:number, env:address:programming-environment-data -> result:boolean [
+def click-on-sandbox-area? click-row:num, click-column:num, env:&:programming-environment-data -> result:bool [
   local-scope
   load-ingredients
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
-  sandbox-left-margin:number <- get *current-sandbox, left:offset
-  on-sandbox-side?:boolean <- greater-or-equal click-column, sandbox-left-margin
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  sandbox-left-margin:num <- get *current-sandbox, left:offset
+  on-sandbox-side?:bool <- greater-or-equal click-column, sandbox-left-margin
   return-unless on-sandbox-side?, 0/false
-  first-sandbox:address:sandbox-data <- get *env, sandbox:offset
+  first-sandbox:&:sandbox-data <- get *env, sandbox:offset
   return-unless first-sandbox, 0/false
-  first-sandbox-begins:number <- get *first-sandbox, starting-row-on-screen:offset
+  first-sandbox-begins:num <- get *first-sandbox, starting-row-on-screen:offset
   result <- greater-or-equal click-row, first-sandbox-begins
 ]
 
-def empty-editor? editor:address:editor-data -> result:boolean [
+def empty-editor? editor:&:editor-data -> result:bool [
   local-scope
   load-ingredients
-  head:address:duplex-list:character <- get *editor, data:offset
-  first:address:duplex-list:character <- next head
+  head:&:duplex-list:char <- get *editor, data:offset
+  first:&:duplex-list:char <- next head
   result <- not first
 ]
 
-def within-range? x:number, low:number, high:number -> result:boolean [
+def within-range? x:num, low:num, high:num -> result:bool [
   local-scope
   load-ingredients
-  not-too-far-left?:boolean <- greater-or-equal x, low
-  not-too-far-right?:boolean <- lesser-or-equal x, high
+  not-too-far-left?:bool <- greater-or-equal x, low
+  not-too-far-right?:bool <- lesser-or-equal x, high
   result <- and not-too-far-left? not-too-far-right?
 ]
 
@@ -233,8 +233,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -252,7 +252,7 @@ recipe foo [
     left-click 3, 70  # click 'copy' button
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # copy doesn't happen
   screen-should-contain [
@@ -270,7 +270,7 @@ recipe foo [
     type [1]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
diff --git a/edit/007-sandbox-delete.mu b/edit/007-sandbox-delete.mu
index 3dac73f6..89c77a8c 100644
--- a/edit/007-sandbox-delete.mu
+++ b/edit/007-sandbox-delete.mu
@@ -5,7 +5,7 @@ scenario deleting-sandboxes [
   assume-screen 100/width, 15/height
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run a few commands
   assume-console [
     left-click 1, 80
@@ -14,7 +14,7 @@ scenario deleting-sandboxes [
     type [add 2, 2]
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -35,7 +35,7 @@ scenario deleting-sandboxes [
     left-click 7, 85
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -53,7 +53,7 @@ scenario deleting-sandboxes [
     left-click 3, 99
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -67,7 +67,7 @@ scenario deleting-sandboxes [
 after <global-touch> [
   # support 'delete' button
   {
-    delete?:boolean <- should-attempt-delete? click-row, click-column, env
+    delete?:bool <- should-attempt-delete? click-row, click-column, env
     break-unless delete?
     delete?, env <- try-delete-sandbox click-row, env
     break-unless delete?
@@ -80,68 +80,68 @@ after <global-touch> [
 ]
 
 # some preconditions for attempting to delete a sandbox
-def should-attempt-delete? click-row:number, click-column:number, env:address:programming-environment-data -> result:boolean [
+def should-attempt-delete? click-row:num, click-column:num, env:&:programming-environment-data -> result:bool [
   local-scope
   load-ingredients
   # are we below the sandbox editor?
-  click-sandbox-area?:boolean <- click-on-sandbox-area? click-row, click-column, env
+  click-sandbox-area?:bool <- click-on-sandbox-area? click-row, click-column, env
   reply-unless click-sandbox-area?, 0/false
   # narrower, is the click in the columns spanning the 'copy' button?
-  first-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  first-sandbox:&:editor-data <- get *env, current-sandbox:offset
   assert first-sandbox, [!!]
-  sandbox-left-margin:number <- get *first-sandbox, left:offset
-  sandbox-right-margin:number <- get *first-sandbox, right:offset
-  _, _, _, _, delete-button-left:number <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
+  sandbox-left-margin:num <- get *first-sandbox, left:offset
+  sandbox-right-margin:num <- get *first-sandbox, right:offset
+  _, _, _, _, delete-button-left:num <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
   result <- within-range? click-column, delete-button-left, sandbox-right-margin
 ]
 
-def try-delete-sandbox click-row:number, env:address:programming-environment-data -> clicked-on-delete-button?:boolean, env:address:programming-environment-data [
+def try-delete-sandbox click-row:num, env:&:programming-environment-data -> clicked-on-delete-button?:bool, env:&:programming-environment-data [
   local-scope
   load-ingredients
   # identify the sandbox to delete, if the click was actually on the 'delete' button
-  sandbox:address:sandbox-data <- find-sandbox env, click-row
+  sandbox:&:sandbox-data <- find-sandbox env, click-row
   return-unless sandbox, 0/false
   clicked-on-delete-button? <- copy 1/true
   env <- delete-sandbox env, sandbox
 ]
 
-def delete-sandbox env:address:programming-environment-data, sandbox:address:sandbox-data -> env:address:programming-environment-data [
+def delete-sandbox env:&:programming-environment-data, sandbox:&:sandbox-data -> env:&:programming-environment-data [
   local-scope
   load-ingredients
-  curr-sandbox:address:sandbox-data <- get *env, sandbox:offset
-  first-sandbox?:boolean <- equal curr-sandbox, sandbox
+  curr-sandbox:&:sandbox-data <- get *env, sandbox:offset
+  first-sandbox?:bool <- equal curr-sandbox, sandbox
   {
     # first sandbox? pop
     break-unless first-sandbox?
-    next-sandbox:address:sandbox-data <- get *curr-sandbox, next-sandbox:offset
+    next-sandbox:&:sandbox-data <- get *curr-sandbox, next-sandbox:offset
     *env <- put *env, sandbox:offset, next-sandbox
   }
   {
     # not first sandbox?
     break-if first-sandbox?
-    prev-sandbox:address:sandbox-data <- copy curr-sandbox
+    prev-sandbox:&:sandbox-data <- copy curr-sandbox
     curr-sandbox <- get *curr-sandbox, next-sandbox:offset
     {
       assert curr-sandbox, [sandbox not found! something is wrong.]
-      found?:boolean <- equal curr-sandbox, sandbox
+      found?:bool <- equal curr-sandbox, sandbox
       break-if found?
       prev-sandbox <- copy curr-sandbox
       curr-sandbox <- get *curr-sandbox, next-sandbox:offset
       loop
     }
     # snip sandbox out of its list
-    next-sandbox:address:sandbox-data <- get *curr-sandbox, next-sandbox:offset
+    next-sandbox:&:sandbox-data <- get *curr-sandbox, next-sandbox:offset
     *prev-sandbox <- put *prev-sandbox, next-sandbox:offset, next-sandbox
   }
   # update sandbox count
-  sandbox-count:number <- get *env, number-of-sandboxes:offset
+  sandbox-count:num <- get *env, number-of-sandboxes:offset
   sandbox-count <- subtract sandbox-count, 1
   *env <- put *env, number-of-sandboxes:offset, sandbox-count
   # reset scroll if deleted sandbox was last
   {
     break-if next-sandbox
-    render-from:number <- get *env, render-from:offset
-    reset-scroll?:boolean <- equal render-from, sandbox-count
+    render-from:num <- get *env, render-from:offset
+    reset-scroll?:bool <- equal render-from, sandbox-count
     break-unless reset-scroll?
     *env <- put *env, render-from:offset, -1
   }
@@ -153,8 +153,8 @@ scenario deleting-sandbox-after-scroll [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes and scroll to second
   assume-console [
     press ctrl-n
@@ -164,7 +164,7 @@ scenario deleting-sandbox-after-scroll [
     press F4
     press page-down
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -179,7 +179,7 @@ scenario deleting-sandbox-after-scroll [
     left-click 6, 99
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # second sandbox shows in editor; scroll resets to display first sandbox
   screen-should-contain [
@@ -199,8 +199,8 @@ scenario deleting-top-sandbox-after-scroll [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes and scroll to second
   assume-console [
     press ctrl-n
@@ -210,7 +210,7 @@ scenario deleting-top-sandbox-after-scroll [
     press F4
     press page-down
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -225,7 +225,7 @@ scenario deleting-top-sandbox-after-scroll [
     left-click 2, 99
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # second sandbox shows in editor; scroll resets to display first sandbox
   screen-should-contain [
@@ -245,8 +245,8 @@ scenario deleting-final-sandbox-after-scroll [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes and scroll to second
   assume-console [
     press ctrl-n
@@ -257,7 +257,7 @@ scenario deleting-final-sandbox-after-scroll [
     press page-down
     press page-down
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -272,7 +272,7 @@ scenario deleting-final-sandbox-after-scroll [
     left-click 2, 99
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # implicitly scroll up to first sandbox
   screen-should-contain [
@@ -293,8 +293,8 @@ scenario deleting-updates-sandbox-count [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes
   assume-console [
     press ctrl-n
@@ -303,7 +303,7 @@ scenario deleting-updates-sandbox-count [
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -323,7 +323,7 @@ scenario deleting-updates-sandbox-count [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # shouldn't go past last sandbox
   screen-should-contain [
diff --git a/edit/008-sandbox-edit.mu b/edit/008-sandbox-edit.mu
index 2b6a1179..9a8c767f 100644
--- a/edit/008-sandbox-edit.mu
+++ b/edit/008-sandbox-edit.mu
@@ -13,8 +13,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -30,7 +30,7 @@ recipe foo [
     left-click 3, 55
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # it pops back into editor
   screen-should-contain [
@@ -47,7 +47,7 @@ recipe foo [
     type [0]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -73,8 +73,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -90,7 +90,7 @@ recipe foo [
     left-click 3, 68
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # it pops back into editor
   screen-should-contain [
@@ -107,7 +107,7 @@ recipe foo [
     type [0]
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -123,7 +123,7 @@ recipe foo [
 after <global-touch> [
   # support 'edit' button
   {
-    edit?:boolean <- should-attempt-edit? click-row, click-column, env
+    edit?:bool <- should-attempt-edit? click-row, click-column, env
     break-unless edit?
     edit?, env <- try-edit-sandbox click-row, env
     break-unless edit?
@@ -136,35 +136,35 @@ after <global-touch> [
 ]
 
 # some preconditions for attempting to edit a sandbox
-def should-attempt-edit? click-row:number, click-column:number, env:address:programming-environment-data -> result:boolean [
+def should-attempt-edit? click-row:num, click-column:num, env:&:programming-environment-data -> result:bool [
   local-scope
   load-ingredients
   # are we below the sandbox editor?
-  click-sandbox-area?:boolean <- click-on-sandbox-area? click-row, click-column, env
+  click-sandbox-area?:bool <- click-on-sandbox-area? click-row, click-column, env
   reply-unless click-sandbox-area?, 0/false
   # narrower, is the click in the columns spanning the 'edit' button?
-  first-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  first-sandbox:&:editor-data <- get *env, current-sandbox:offset
   assert first-sandbox, [!!]
-  sandbox-left-margin:number <- get *first-sandbox, left:offset
-  sandbox-right-margin:number <- get *first-sandbox, right:offset
-  edit-button-left:number, edit-button-right:number, _ <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
-  edit-button-vertical-area?:boolean <- within-range? click-column, edit-button-left, edit-button-right
+  sandbox-left-margin:num <- get *first-sandbox, left:offset
+  sandbox-right-margin:num <- get *first-sandbox, right:offset
+  edit-button-left:num, edit-button-right:num, _ <- sandbox-menu-columns sandbox-left-margin, sandbox-right-margin
+  edit-button-vertical-area?:bool <- within-range? click-column, edit-button-left, edit-button-right
   reply-unless edit-button-vertical-area?, 0/false
   # finally, is sandbox editor empty?
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   result <- empty-editor? current-sandbox
 ]
 
-def try-edit-sandbox click-row:number, env:address:programming-environment-data -> clicked-on-edit-button?:boolean, env:address:programming-environment-data [
+def try-edit-sandbox click-row:num, env:&:programming-environment-data -> clicked-on-edit-button?:bool, env:&:programming-environment-data [
   local-scope
   load-ingredients
   # identify the sandbox to edit, if the click was actually on the 'edit' button
-  sandbox:address:sandbox-data <- find-sandbox env, click-row
+  sandbox:&:sandbox-data <- find-sandbox env, click-row
   return-unless sandbox, 0/false
   clicked-on-edit-button? <- copy 1/true
   # 'edit' button = 'copy' button + 'delete' button
   text:text <- get *sandbox, data:offset
-  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
   current-sandbox <- insert-text current-sandbox, text
   env <- delete-sandbox env, sandbox
   # reset scroll
@@ -180,12 +180,12 @@ scenario sandbox-with-print-can-be-edited [
   1:text <- new []
   # right editor contains an instruction
   2:text <- new [print-integer screen, 4]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the sandbox
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -206,7 +206,7 @@ scenario sandbox-with-print-can-be-edited [
     left-click 3, 65
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -223,8 +223,8 @@ scenario editing-sandbox-after-scrolling-resets-scroll [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes and scroll to second
   assume-console [
     press ctrl-n
@@ -235,7 +235,7 @@ scenario editing-sandbox-after-scrolling-resets-scroll [
     press page-down
     press page-down
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -250,7 +250,7 @@ scenario editing-sandbox-after-scrolling-resets-scroll [
     left-click 2, 55
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # second sandbox shows in editor; scroll resets to display first sandbox
   screen-should-contain [
@@ -271,8 +271,8 @@ scenario editing-sandbox-updates-sandbox-count [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  render-all screen, 3:address:programming-environment-data, render
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:programming-environment-data, render
   # create 2 sandboxes
   assume-console [
     press ctrl-n
@@ -281,7 +281,7 @@ scenario editing-sandbox-updates-sandbox-count [
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -300,7 +300,7 @@ scenario editing-sandbox-updates-sandbox-count [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # no change in contents
   screen-should-contain [
@@ -322,7 +322,7 @@ scenario editing-sandbox-updates-sandbox-count [
     press page-down
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # screen should show just final sandbox with the right index (1)
   screen-should-contain [
diff --git a/edit/009-sandbox-test.mu b/edit/009-sandbox-test.mu
index 7ff9125d..c62702e8 100644
--- a/edit/009-sandbox-test.mu
+++ b/edit/009-sandbox-test.mu
@@ -13,8 +13,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -30,7 +30,7 @@ recipe foo [
     left-click 5, 51
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # color toggles to green
   screen-should-contain-in-color 2/green, [
@@ -45,8 +45,8 @@ recipe foo [
   ]
   # cursor should remain unmoved
   run [
-    4:character/cursor <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor
+    4:char/cursor <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor
   ]
   screen-should-contain [
     .                                                                                 run (F4)           .
@@ -69,7 +69,7 @@ recipe foo [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # result turns red
   screen-should-contain-in-color 1/red, [
@@ -86,7 +86,7 @@ recipe foo [
 
 # this requires tracking a couple more things
 container sandbox-data [
-  response-starting-row-on-screen:number
+  response-starting-row-on-screen:num
   expected-response:text
 ]
 
@@ -113,18 +113,18 @@ before <end-restore-sandbox> [
 after <global-touch> [
   # check if it's inside the output of any sandbox
   {
-    sandbox-left-margin:number <- get *current-sandbox, left:offset
-    click-column:number <- get t, column:offset
-    on-sandbox-side?:boolean <- greater-or-equal click-column, sandbox-left-margin
+    sandbox-left-margin:num <- get *current-sandbox, left:offset
+    click-column:num <- get t, column:offset
+    on-sandbox-side?:bool <- greater-or-equal click-column, sandbox-left-margin
     break-unless on-sandbox-side?
-    first-sandbox:address:sandbox-data <- get *env, sandbox:offset
+    first-sandbox:&:sandbox-data <- get *env, sandbox:offset
     break-unless first-sandbox
-    first-sandbox-begins:number <- get *first-sandbox, starting-row-on-screen:offset
-    click-row:number <- get t, row:offset
-    below-sandbox-editor?:boolean <- greater-or-equal click-row, first-sandbox-begins
+    first-sandbox-begins:num <- get *first-sandbox, starting-row-on-screen:offset
+    click-row:num <- get t, row:offset
+    below-sandbox-editor?:bool <- greater-or-equal click-row, first-sandbox-begins
     break-unless below-sandbox-editor?
     # identify the sandbox whose output is being clicked on
-    sandbox:address:sandbox-data <- find-click-in-sandbox-output env, click-row
+    sandbox:&:sandbox-data <- find-click-in-sandbox-output env, click-row
     break-unless sandbox
     # toggle its expected-response, and save session
     sandbox <- toggle-expected-response sandbox
@@ -138,33 +138,33 @@ after <global-touch> [
   }
 ]
 
-def find-click-in-sandbox-output env:address:programming-environment-data, click-row:number -> sandbox:address:sandbox-data [
+def find-click-in-sandbox-output env:&:programming-environment-data, click-row:num -> sandbox:&:sandbox-data [
   local-scope
   load-ingredients
   # assert click-row >= sandbox.starting-row-on-screen
-  sandbox:address:sandbox-data <- get *env, sandbox:offset
-  start:number <- get *sandbox, starting-row-on-screen:offset
-  clicked-on-sandboxes?:boolean <- greater-or-equal click-row, start
+  sandbox:&:sandbox-data <- get *env, sandbox:offset
+  start:num <- get *sandbox, starting-row-on-screen:offset
+  clicked-on-sandboxes?:bool <- greater-or-equal click-row, start
   assert clicked-on-sandboxes?, [extract-sandbox called on click to sandbox editor]
   # while click-row < sandbox.next-sandbox.starting-row-on-screen
   {
-    next-sandbox:address:sandbox-data <- get *sandbox, next-sandbox:offset
+    next-sandbox:&:sandbox-data <- get *sandbox, next-sandbox:offset
     break-unless next-sandbox
-    next-start:number <- get *next-sandbox, starting-row-on-screen:offset
-    found?:boolean <- lesser-than click-row, next-start
+    next-start:num <- get *next-sandbox, starting-row-on-screen:offset
+    found?:bool <- lesser-than click-row, next-start
     break-if found?
     sandbox <- copy next-sandbox
     loop
   }
   # return sandbox if click is in its output region
-  response-starting-row:number <- get *sandbox, response-starting-row-on-screen:offset
+  response-starting-row:num <- get *sandbox, response-starting-row-on-screen:offset
   return-unless response-starting-row, 0/no-click-in-sandbox-output
-  click-in-response?:boolean <- greater-or-equal click-row, response-starting-row
+  click-in-response?:bool <- greater-or-equal click-row, response-starting-row
   return-unless click-in-response?, 0/no-click-in-sandbox-output
   return sandbox
 ]
 
-def toggle-expected-response sandbox:address:sandbox-data -> sandbox:address:sandbox-data [
+def toggle-expected-response sandbox:&:sandbox-data -> sandbox:&:sandbox-data [
   local-scope
   load-ingredients
   expected-response:text <- get *sandbox, expected-response:offset
@@ -188,13 +188,13 @@ after <render-sandbox-response> [
     *sandbox <- put *sandbox, response-starting-row-on-screen:offset, row
     expected-response:text <- get *sandbox, expected-response:offset
     break-unless expected-response  # fall-through to print in grey
-    response-is-expected?:boolean <- equal expected-response, sandbox-response
+    response-is-expected?:bool <- equal expected-response, sandbox-response
     {
-      break-if response-is-expected?:boolean
+      break-if response-is-expected?:bool
       row, screen <- render-text screen, sandbox-response, left, right, 1/red, row
     }
     {
-      break-unless response-is-expected?:boolean
+      break-unless response-is-expected?:bool
       row, screen <- render-text screen, sandbox-response, left, right, 2/green, row
     }
     jump +render-sandbox-end:label
diff --git a/edit/010-sandbox-trace.mu b/edit/010-sandbox-trace.mu
index 6ac771f9..cc904f6d 100644
--- a/edit/010-sandbox-trace.mu
+++ b/edit/010-sandbox-trace.mu
@@ -13,8 +13,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -29,9 +29,9 @@ recipe foo [
     left-click 4, 51
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    4:character/cursor-icon <- copy 9251/␣
-    print screen:address:screen, 4:character/cursor-icon
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    4:char/cursor-icon <- copy 9251/␣
+    print screen:&:screen, 4:char/cursor-icon
   ]
   # trace now printed and cursor shouldn't have budged
   screen-should-contain [
@@ -55,8 +55,8 @@ recipe foo [
     left-click 4, 55
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
-    print screen:address:screen, 4:character/cursor-icon
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    print screen:&:screen, 4:char/cursor-icon
   ]
   # trace hidden again
   screen-should-contain [
@@ -84,8 +84,8 @@ recipe foo [
   assume-console [
     press F4
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -101,7 +101,7 @@ recipe foo [
     left-click 4, 51
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # trace now printed above result
   screen-should-contain [
@@ -128,8 +128,8 @@ scenario clicking-on-app-trace-does-nothing [
     press F4
     left-click 4, 51
   ]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -143,7 +143,7 @@ scenario clicking-on-app-trace-does-nothing [
     left-click 5, 57
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # no change; doesn't die
   screen-should-contain [
@@ -158,15 +158,15 @@ scenario clicking-on-app-trace-does-nothing [
 
 container sandbox-data [
   trace:text
-  display-trace?:boolean
+  display-trace?:bool
 ]
 
 # replaced in a later layer
-def! update-sandbox sandbox:address:sandbox-data, env:address:programming-environment-data, idx:number -> sandbox:address:sandbox-data, env:address:programming-environment-data [
+def! update-sandbox sandbox:&:sandbox-data, env:&:programming-environment-data, idx:num -> sandbox:&:sandbox-data, env:&:programming-environment-data [
   local-scope
   load-ingredients
   data:text <- get *sandbox, data:offset
-  response:text, _, fake-screen:address:screen, trace:text <- run-sandboxed data
+  response:text, _, fake-screen:&:screen, trace:text <- run-sandboxed data
   *sandbox <- put *sandbox, response:offset, response
   *sandbox <- put *sandbox, screen:offset, fake-screen
   *sandbox <- put *sandbox, trace:offset, trace
@@ -176,21 +176,21 @@ def! update-sandbox sandbox:address:sandbox-data, env:address:programming-enviro
 after <global-touch> [
   # check if it's inside the code of any sandbox
   {
-    sandbox-left-margin:number <- get *current-sandbox, left:offset
-    click-column:number <- get t, column:offset
-    on-sandbox-side?:boolean <- greater-or-equal click-column, sandbox-left-margin
+    sandbox-left-margin:num <- get *current-sandbox, left:offset
+    click-column:num <- get t, column:offset
+    on-sandbox-side?:bool <- greater-or-equal click-column, sandbox-left-margin
     break-unless on-sandbox-side?
-    first-sandbox:address:sandbox-data <- get *env, sandbox:offset
+    first-sandbox:&:sandbox-data <- get *env, sandbox:offset
     break-unless first-sandbox
-    first-sandbox-begins:number <- get *first-sandbox, starting-row-on-screen:offset
-    click-row:number <- get t, row:offset
-    below-sandbox-editor?:boolean <- greater-or-equal click-row, first-sandbox-begins
+    first-sandbox-begins:num <- get *first-sandbox, starting-row-on-screen:offset
+    click-row:num <- get t, row:offset
+    below-sandbox-editor?:bool <- greater-or-equal click-row, first-sandbox-begins
     break-unless below-sandbox-editor?
     # identify the sandbox whose code is being clicked on
-    sandbox:address:sandbox-data <- find-click-in-sandbox-code env, click-row
+    sandbox:&:sandbox-data <- find-click-in-sandbox-code env, click-row
     break-unless sandbox
     # toggle its display-trace? property
-    x:boolean <- get *sandbox, display-trace?:offset
+    x:bool <- get *sandbox, display-trace?:offset
     x <- not x
     *sandbox <- put *sandbox, display-trace?:offset, x
     hide-screen screen
@@ -202,30 +202,30 @@ after <global-touch> [
   }
 ]
 
-def find-click-in-sandbox-code env:address:programming-environment-data, click-row:number -> sandbox:address:sandbox-data [
+def find-click-in-sandbox-code env:&:programming-environment-data, click-row:num -> sandbox:&:sandbox-data [
   local-scope
   load-ingredients
   # assert click-row >= sandbox.starting-row-on-screen
   sandbox <- get *env, sandbox:offset
-  start:number <- get *sandbox, starting-row-on-screen:offset
-  clicked-on-sandboxes?:boolean <- greater-or-equal click-row, start
+  start:num <- get *sandbox, starting-row-on-screen:offset
+  clicked-on-sandboxes?:bool <- greater-or-equal click-row, start
   assert clicked-on-sandboxes?, [extract-sandbox called on click to sandbox editor]
   # while click-row < sandbox.next-sandbox.starting-row-on-screen
   {
-    next-sandbox:address:sandbox-data <- get *sandbox, next-sandbox:offset
+    next-sandbox:&:sandbox-data <- get *sandbox, next-sandbox:offset
     break-unless next-sandbox
-    next-start:number <- get *next-sandbox, starting-row-on-screen:offset
-    found?:boolean <- lesser-than click-row, next-start
+    next-start:num <- get *next-sandbox, starting-row-on-screen:offset
+    found?:bool <- lesser-than click-row, next-start
     break-if found?
     sandbox <- copy next-sandbox
     loop
   }
   # return sandbox if click is in its code region
-  code-ending-row:number <- get *sandbox, code-ending-row-on-screen:offset
-  click-above-response?:boolean <- lesser-than click-row, code-ending-row
-  start:number <- get *sandbox, starting-row-on-screen:offset
-  click-below-menu?:boolean <- greater-than click-row, start
-  click-on-sandbox-code?:boolean <- and click-above-response?, click-below-menu?
+  code-ending-row:num <- get *sandbox, code-ending-row-on-screen:offset
+  click-above-response?:bool <- lesser-than click-row, code-ending-row
+  start:num <- get *sandbox, starting-row-on-screen:offset
+  click-below-menu?:bool <- greater-than click-row, start
+  click-on-sandbox-code?:bool <- and click-above-response?, click-below-menu?
   {
     break-if click-on-sandbox-code?
     return 0/no-click-in-sandbox-output
@@ -236,7 +236,7 @@ def find-click-in-sandbox-code env:address:programming-environment-data, click-r
 # when rendering a sandbox, dump its trace before response/warning if display-trace? property is set
 after <render-sandbox-results> [
   {
-    display-trace?:boolean <- get *sandbox, display-trace?:offset
+    display-trace?:bool <- get *sandbox, display-trace?:offset
     break-unless display-trace?
     sandbox-trace:text <- get *sandbox, trace:offset
     break-unless sandbox-trace  # nothing to print; move on
diff --git a/edit/011-errors.mu b/edit/011-errors.mu
index 31ad561d..41a53be5 100644
--- a/edit/011-errors.mu
+++ b/edit/011-errors.mu
@@ -5,10 +5,10 @@ container programming-environment-data [
 ]
 
 # copy code from recipe editor, persist, load into mu, save any errors
-def! update-recipes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [
+def! update-recipes env:&:programming-environment-data, screen:&:screen -> errors-found?:bool, env:&:programming-environment-data, screen:&:screen [
   local-scope
   load-ingredients
-  recipes:address:editor-data <- get *env, recipes:offset
+  recipes:&:editor-data <- get *env, recipes:offset
   in:text <- editor-contents recipes
   save [recipes.mu], in
   recipe-errors:text <- reload in
@@ -41,7 +41,7 @@ before <render-recipe-components-end> [
 ]
 
 container programming-environment-data [
-  error-index:number  # index of first sandbox with an error (or -1 if none)
+  error-index:num  # index of first sandbox with an error (or -1 if none)
 ]
 
 after <programming-environment-initialization> [
@@ -54,8 +54,8 @@ after <run-sandboxes-begin> [
 
 before <run-sandboxes-end> [
   {
-    error-index:number <- get *env, error-index:offset
-    sandboxes-completed-successfully?:boolean <- equal error-index, -1
+    error-index:num <- get *env, error-index:offset
+    sandboxes-completed-successfully?:bool <- equal error-index, -1
     break-if sandboxes-completed-successfully?
     errors-found? <- copy 1/true
   }
@@ -64,8 +64,8 @@ before <run-sandboxes-end> [
 before <render-components-end> [
   {
     break-if recipe-errors
-    error-index:number <- get *env, error-index:offset
-    sandboxes-completed-successfully?:boolean <- equal error-index, -1
+    error-index:num <- get *env, error-index:offset
+    sandboxes-completed-successfully?:bool <- equal error-index, -1
     break-if sandboxes-completed-successfully?
     error-index-text:text <- to-text error-index
     status:text <- interpolate [errors found (_)    ], error-index-text
@@ -77,26 +77,26 @@ container sandbox-data [
   errors:text
 ]
 
-def! update-sandbox sandbox:address:sandbox-data, env:address:programming-environment-data, idx:number -> sandbox:address:sandbox-data, env:address:programming-environment-data [
+def! update-sandbox sandbox:&:sandbox-data, env:&:programming-environment-data, idx:num -> sandbox:&:sandbox-data, env:&:programming-environment-data [
   local-scope
   load-ingredients
   data:text <- get *sandbox, data:offset
-  response:text, errors:text, fake-screen:address:screen, trace:text, completed?:boolean <- run-sandboxed data
+  response:text, errors:text, fake-screen:&:screen, trace:text, completed?:bool <- run-sandboxed data
   *sandbox <- put *sandbox, response:offset, response
   *sandbox <- put *sandbox, errors:offset, errors
   *sandbox <- put *sandbox, screen:offset, fake-screen
   *sandbox <- put *sandbox, trace:offset, trace
   {
     break-if errors
-    break-if completed?:boolean
+    break-if completed?:bool
     errors <- new [took too long!
 ]
     *sandbox <- put *sandbox, errors:offset, errors
   }
   {
     break-unless errors
-    error-index:number <- get *env, error-index:offset
-    error-not-set?:boolean <- equal error-index, -1
+    error-index:num <- get *env, error-index:offset
+    error-not-set?:bool <- equal error-index, -1
     break-unless error-not-set?
     *env <- put *env, error-index:offset, idx
   }
@@ -119,25 +119,25 @@ scenario run-shows-errors-in-get [
   assume-screen 100/width, 15/height
   1:text <- new [ 
 recipe foo [
-  get 123:number, foo:offset
+  get 123:num, foo:offset
 ]]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
-    .  get 123:number, foo:offset                      ┊                                                 .
+    .  get 123:num, foo:offset                         ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: unknown element 'foo' in container 'number'  ┊                                                 .
     .foo: first ingredient of 'get' should be a contai↩┊                                                 .
-    .ner, but got '123:number'                         ┊                                                 .
+    .ner, but got '123:num'                            ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
     .                                                  ┊                                                 .
   ]
@@ -149,7 +149,7 @@ recipe foo [
     .                                                                                                    .
     .foo: unknown element 'foo' in container 'number'                                                    .
     .foo: first ingredient of 'get' should be a contai                                                   .
-    .ner, but got '123:number'                                                                           .
+    .ner, but got '123:num'                                                                              .
     .                                                                                                    .
   ]
 ]
@@ -159,7 +159,7 @@ scenario run-updates-status-with-first-erroneous-sandbox [
   assume-screen 100/width, 15/height
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     left-click 3, 80
     # create invalid sandbox 1
@@ -170,7 +170,7 @@ scenario run-updates-status-with-first-erroneous-sandbox [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # status line shows that error is in first sandbox
   screen-should-contain [
@@ -183,7 +183,7 @@ scenario run-updates-status-with-first-erroneous-sandbox-2 [
   assume-screen 100/width, 15/height
   1:text <- new []
   2:text <- new []
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     left-click 3, 80
     # create invalid sandbox 2
@@ -197,7 +197,7 @@ scenario run-updates-status-with-first-erroneous-sandbox-2 [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # status line shows that error is in second sandbox
   screen-should-contain [
@@ -210,12 +210,12 @@ scenario run-hides-errors-from-past-sandboxes [
   assume-screen 100/width, 15/height
   1:text <- new []
   2:text <- new [get foo, x:offset]  # invalid
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4  # generate error
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   assume-console [
     left-click 3, 58
@@ -224,7 +224,7 @@ scenario run-hides-errors-from-past-sandboxes [
     press F4  # update sandbox
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # error should disappear
   screen-should-contain [
@@ -246,21 +246,21 @@ scenario run-updates-errors-for-shape-shifting-recipes [
   1:text <- new [recipe foo x:_elem -> z:_elem [
 local-scope
 load-ingredients
-y:address:number <- copy 0
+y:&:num <- copy 0
 z <- add x, y
 ]]
   2:text <- new [foo 2]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .  errors found (0)                                                               run (F4)           .
     .recipe foo x:_elem -> z:_elem [                   ┊                                                 .
     .local-scope                                       ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .load-ingredients                                  ┊0   edit          copy            delete         .
-    .y:address:number <- copy 0                        ┊foo 2                                            .
+    .y:&:num <- copy 0                                 ┊foo 2                                            .
     .z <- add x, y                                     ┊foo_2: 'add' requires number ingredients, but go↩.
     .]                                                 ┊t 'y'                                            .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -271,7 +271,7 @@ z <- add x, y
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # error should remain unchanged
   screen-should-contain [
@@ -279,7 +279,7 @@ z <- add x, y
     .recipe foo x:_elem -> z:_elem [                   ┊                                                 .
     .local-scope                                       ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .load-ingredients                                  ┊0   edit          copy            delete         .
-    .y:address:number <- copy 0                        ┊foo 2                                            .
+    .y:&:num <- copy 0                                 ┊foo 2                                            .
     .z <- add x, y                                     ┊foo_3: 'add' requires number ingredients, but go↩.
     .]                                                 ┊t 'y'                                            .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
@@ -291,24 +291,24 @@ scenario run-avoids-spurious-errors-on-reloading-shape-shifting-recipes [
   trace-until 100/app  # trace too long
   assume-screen 100/width, 15/height
   # overload a well-known shape-shifting recipe
-  1:text <- new [recipe length l:address:list:_elem -> n:number [
+  1:text <- new [recipe length l:&:list:_elem -> n:num [
 ]]
   # call code that uses other variants of it, but not it itself
-  2:text <- new [x:address:list:number <- copy 0
+  2:text <- new [x:&:list:num <- copy 0
 to-text x]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run it once
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   # no errors anywhere on screen (can't check anything else, since to-text will return an address)
   screen-should-contain-in-color 1/red, [
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
-    .                                                                         <-                         .
+    .                                                                <-                                  .
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
@@ -325,7 +325,7 @@ to-text x]
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # still no errors
   screen-should-contain-in-color 1/red, [
@@ -333,7 +333,7 @@ to-text x]
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
-    .                                                                         <-                         .
+    .                                                                <-                                  .
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
@@ -355,12 +355,12 @@ recipe foo [
   x <- copy 0
 ]]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
@@ -381,12 +381,12 @@ recipe foo \\[
   x <- copy 0
 ]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
@@ -406,27 +406,27 @@ scenario run-shows-get-on-non-container-errors [
   1:text <- new [ 
 recipe foo [
   local-scope
-  x:address:point <- new point:type
-  get x:address:point, 1:offset
+  x:&:point <- new point:type
+  get x:&:point, 1:offset
 ]]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .  local-scope                                     ┊                                                 .
-    .  x:address:point <- new point:type               ┊                                                 .
-    .  get x:address:point, 1:offset                   ┊                                                 .
+    .  x:&:point <- new point:type                     ┊                                                 .
+    .  get x:&:point, 1:offset                         ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: first ingredient of 'get' should be a contai↩┊                                                 .
-    .ner, but got 'x:address:point'                    ┊                                                 .
+    .ner, but got 'x:&:point'                          ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
     .                                                  ┊                                                 .
   ]
@@ -438,29 +438,29 @@ scenario run-shows-non-literal-get-argument-errors [
   1:text <- new [ 
 recipe foo [
   local-scope
-  x:number <- copy 0
-  y:address:point <- new point:type
-  get *y:address:point, x:number
+  x:num <- copy 0
+  y:&:point <- new point:type
+  get *y:&:point, x:num
 ]]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .  local-scope                                     ┊                                                 .
-    .  x:number <- copy 0                              ┊                                                 .
-    .  y:address:point <- new point:type               ┊                                                 .
-    .  get *y:address:point, x:number                  ┊                                                 .
+    .  x:num <- copy 0                                 ┊                                                 .
+    .  y:&:point <- new point:type                     ┊                                                 .
+    .  get *y:&:point, x:num                           ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: second ingredient of 'get' should have type ↩┊                                                 .
-    .'offset', but got 'x:number'                      ┊                                                 .
+    .'offset', but got 'x:num'                         ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
     .                                                  ┊                                                 .
   ]
@@ -473,20 +473,20 @@ scenario run-shows-errors-everytime [
   1:text <- new [ 
 recipe foo [
   local-scope
-  x:number <- copy y:number
+  x:num <- copy y:num
 ]]
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .  local-scope                                     ┊                                                 .
-    .  x:number <- copy y:number                       ┊                                                 .
+    .  x:num <- copy y:num                             ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: use before set: 'y'                          ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
@@ -497,14 +497,14 @@ recipe foo [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found                                                                   run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .  local-scope                                     ┊                                                 .
-    .  x:number <- copy y:number                       ┊                                                 .
+    .  x:num <- copy y:num                             ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: use before set: 'y'                          ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
@@ -518,14 +518,14 @@ scenario run-instruction-and-print-errors [
   # left editor is empty
   1:text <- new []
   # right editor contains an illegal instruction
-  2:text <- new [get 1234:number, foo:offset]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  2:text <- new [get 1234:num, foo:offset]
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that screen prints error message in red
   screen-should-contain [
@@ -533,10 +533,10 @@ scenario run-instruction-and-print-errors [
     .                                                  ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .                                                  ┊0   edit          copy            delete         .
-    .                                                  ┊get 1234:number, foo:offset                      .
+    .                                                  ┊get 1234:num, foo:offset                         .
     .                                                  ┊unknown element 'foo' in container 'number'      .
     .                                                  ┊first ingredient of 'get' should be a container,↩.
-    .                                                  ┊ but got '1234:number'                           .
+    .                                                  ┊ but got '1234:num'                              .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .                                                  ┊                                                 .
   ]
@@ -545,7 +545,7 @@ scenario run-instruction-and-print-errors [
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
-    .                                                   get 1234:number, foo:offset                      .
+    .                                                   get 1234:num, foo:offset                         .
     .                                                                                                    .
     .                                                                                                    .
     .                                                                                                    .
@@ -558,7 +558,7 @@ scenario run-instruction-and-print-errors [
     .                                                                                                    .
     .                                                   unknown element 'foo' in container 'number'      .
     .                                                   first ingredient of 'get' should be a container, .
-    .                                                    but got '1234:number'                           .
+    .                                                    but got '1234:num'                              .
     .                                                                                                    .
   ]
   screen-should-contain-in-color 245/grey, [
@@ -581,15 +581,15 @@ scenario run-instruction-and-print-errors-only-once [
   # left editor is empty
   1:text <- new []
   # right editor contains an illegal instruction
-  2:text <- new [get 1234:number, foo:offset]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  2:text <- new [get 1234:num, foo:offset]
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors multiple times
   assume-console [
     press F4
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # check that screen prints error message just once
   screen-should-contain [
@@ -597,10 +597,10 @@ scenario run-instruction-and-print-errors-only-once [
     .                                                  ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .                                                  ┊0   edit          copy            delete         .
-    .                                                  ┊get 1234:number, foo:offset                      .
+    .                                                  ┊get 1234:num, foo:offset                         .
     .                                                  ┊unknown element 'foo' in container 'number'      .
     .                                                  ┊first ingredient of 'get' should be a container,↩.
-    .                                                  ┊ but got '1234:number'                           .
+    .                                                  ┊ but got '1234:num'                              .
     .                                                  ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .                                                  ┊                                                 .
   ]
@@ -617,13 +617,13 @@ scenario sandbox-can-handle-infinite-loop [
 ]]
   # right editor contains an instruction
   2:text <- new [foo]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the sandbox
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   screen-should-contain [
     .  errors found (0)                                                               run (F4)           .
@@ -643,28 +643,28 @@ scenario sandbox-with-errors-shows-trace [
   # generate a stash and a error
   1:text <- new [recipe foo [
 local-scope
-a:number <- next-ingredient
-b:number <- next-ingredient
+a:num <- next-ingredient
+b:num <- next-ingredient
 stash [dividing by], b
-_, c:number <- divide-with-remainder a, b
+_, c:num <- divide-with-remainder a, b
 reply b
 ]]
   2:text <- new [foo 4, 0]
-  3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:text, 2:text
+  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run
   assume-console [
     press F4
   ]
-  event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   # screen prints error message
   screen-should-contain [
     .  errors found (0)                                                               run (F4)           .
     .recipe foo [                                      ┊                                                 .
     .local-scope                                       ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
-    .a:number <- next-ingredient                       ┊0   edit          copy            delete         .
-    .b:number <- next-ingredient                       ┊foo 4, 0                                         .
-    .stash [dividing by], b                            ┊foo: divide by zero in '_, c:number <- divide-wi↩.
-    ._, c:number <- divide-with-remainder a, b         ┊th-remainder a, b'                               .
+    .a:num <- next-ingredient                          ┊0   edit          copy            delete         .
+    .b:num <- next-ingredient                          ┊foo 4, 0                                         .
+    .stash [dividing by], b                            ┊foo: divide by zero in '_, c:num <- divide-with-↩.
+    ._, c:num <- divide-with-remainder a, b            ┊remainder a, b'                                  .
     .reply b                                           ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .]                                                 ┊                                                 .
   ]
@@ -673,19 +673,19 @@ reply b
     left-click 4, 55
   ]
   run [
-    event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
   ]
   # screen should expand trace
   screen-should-contain [
     .  errors found (0)                                                               run (F4)           .
     .recipe foo [                                      ┊                                                 .
     .local-scope                                       ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
-    .a:number <- next-ingredient                       ┊0   edit          copy            delete         .
-    .b:number <- next-ingredient                       ┊foo 4, 0                                         .
+    .a:num <- next-ingredient                          ┊0   edit          copy            delete         .
+    .b:num <- next-ingredient                          ┊foo 4, 0                                         .
     .stash [dividing by], b                            ┊dividing by 0                                    .
-    ._, c:number <- divide-with-remainder a, b         ┊14 instructions run                              .
-    .reply b                                           ┊foo: divide by zero in '_, c:number <- divide-wi↩.
-    .]                                                 ┊th-remainder a, b'                               .
+    ._, c:num <- divide-with-remainder a, b            ┊14 instructions run                              .
+    .reply b                                           ┊foo: divide by zero in '_, c:num <- divide-with-↩.
+    .]                                                 ┊remainder a, b'                                  .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
   ]
 ]
diff --git a/edit/012-editor-undo.mu b/edit/012-editor-undo.mu
index a245e77d..7e43fd31 100644
--- a/edit/012-editor-undo.mu
+++ b/edit/012-editor-undo.mu
@@ -9,28 +9,28 @@ exclusive-container operation [
 ]
 
 container insert-operation [
-  before-row:number
-  before-column:number
-  before-top-of-screen:address:duplex-list:character
-  after-row:number
-  after-column:number
-  after-top-of-screen:address:duplex-list:character
+  before-row:num
+  before-column:num
+  before-top-of-screen:&:duplex-list:char
+  after-row:num
+  after-column:num
+  after-top-of-screen:&:duplex-list:char
   # inserted text is from 'insert-from' until 'insert-until'; list doesn't have to terminate
-  insert-from:address:duplex-list:character
-  insert-until:address:duplex-list:character
-  tag:number  # event causing this operation; might be used to coalesce runs of similar events
+  insert-from:&:duplex-list:char
+  insert-until:&:duplex-list:char
+  tag:num  # event causing this operation; might be used to coalesce runs of similar events
     # 0: no coalesce (enter+indent)
     # 1: regular alphanumeric characters
 ]
 
 container move-operation [
-  before-row:number
-  before-column:number
-  before-top-of-screen:address:duplex-list:character
-  after-row:number
-  after-column:number
-  after-top-of-screen:address:duplex-list:character
-  tag:number  # event causing this operation; might be used to coalesce runs of similar events
+  before-row:num
+  before-column:num
+  before-top-of-screen:&:duplex-list:char
+  after-row:num
+  after-column:num
+  after-top-of-screen:&:duplex-list:char
+  tag:num  # event causing this operation; might be used to coalesce runs of similar events
     # 0: no coalesce (touch events, etc)
     # 1: left arrow
     # 2: right arrow
@@ -39,16 +39,16 @@ container move-operation [
 ]
 
 container delete-operation [
-  before-row:number
-  before-column:number
-  before-top-of-screen:address:duplex-list:character
-  after-row:number
-  after-column:number
-  after-top-of-screen:address:duplex-list:character
-  deleted-text:address:duplex-list:character
-  delete-from:address:duplex-list:character
-  delete-until:address:duplex-list:character
-  tag:number  # event causing this operation; might be used to coalesce runs of similar events
+  before-row:num
+  before-column:num
+  before-top-of-screen:&:duplex-list:char
+  after-row:num
+  after-column:num
+  after-top-of-screen:&:duplex-list:char
+  deleted-text:&:duplex-list:char
+  delete-from:&:duplex-list:char
+  delete-until:&:duplex-list:char
+  tag:num  # event causing this operation; might be used to coalesce runs of similar events
     # 0: no coalesce (ctrl-k, ctrl-u)
     # 1: backspace
     # 2: delete
@@ -56,21 +56,21 @@ container delete-operation [
 
 # every editor accumulates a list of operations to undo/redo
 container editor-data [
-  undo:address:list:address:operation
-  redo:address:list:address:operation
+  undo:&:list:&:operation
+  redo:&:list:&:operation
 ]
 
 # ctrl-z - undo operation
 after <handle-special-character> [
   {
-    undo?:boolean <- equal c, 26/ctrl-z
+    undo?:bool <- equal c, 26/ctrl-z
     break-unless undo?
-    undo:address:list:address:operation <- get *editor, undo:offset
+    undo:&:list:&:operation <- get *editor, undo:offset
     break-unless undo
-    op:address:operation <- first undo
+    op:&:operation <- first undo
     undo <- rest undo
     *editor <- put *editor, undo:offset, undo
-    redo:address:list:address:operation <- get *editor, redo:offset
+    redo:&:list:&:operation <- get *editor, redo:offset
     redo <- push op, redo
     *editor <- put *editor, redo:offset, redo
     <handle-undo>
@@ -81,14 +81,14 @@ after <handle-special-character> [
 # ctrl-y - redo operation
 after <handle-special-character> [
   {
-    redo?:boolean <- equal c, 25/ctrl-y
+    redo?:bool <- equal c, 25/ctrl-y
     break-unless redo?
-    redo:address:list:address:operation <- get *editor, redo:offset
+    redo:&:list:&:operation <- get *editor, redo:offset
     break-unless redo
-    op:address:operation <- first redo
+    op:&:operation <- first redo
     redo <- rest redo
     *editor <- put *editor, redo:offset, redo
-    undo:address:list:address:operation <- get *editor, undo:offset
+    undo:&:list:&:operation <- get *editor, undo:offset
     undo <- push op, undo
     *editor <- put *editor, undo:offset, undo
     <handle-redo>
@@ -102,18 +102,18 @@ scenario editor-can-undo-typing [
   # create an editor and type a character
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [0]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # character should be gone
   screen-should-contain [
@@ -127,7 +127,7 @@ scenario editor-can-undo-typing [
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -139,24 +139,24 @@ scenario editor-can-undo-typing [
 
 # save operation to undo
 after <insert-character-begin> [
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
-  cursor-before:address:duplex-list:character <- get *editor, before-cursor:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
+  cursor-before:&:duplex-list:char <- get *editor, before-cursor:offset
 ]
 before <insert-character-end> [
-  top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
-  undo:address:list:address:operation <- get *editor, undo:offset
+  top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
+  undo:&:list:&:operation <- get *editor, undo:offset
   {
     # if previous operation was an insert, coalesce this operation with it
     break-unless undo
-    op:address:operation <- first undo
-    typing:insert-operation, is-insert?:boolean <- maybe-convert *op, typing:variant
+    op:&:operation <- first undo
+    typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     break-unless is-insert?
-    previous-coalesce-tag:number <- get typing, tag:offset
+    previous-coalesce-tag:num <- get typing, tag:offset
     break-unless previous-coalesce-tag
-    before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-    insert-until:address:duplex-list:character <- next before-cursor
+    before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+    insert-until:&:duplex-list:char <- next before-cursor
     typing <- put typing, insert-until:offset, insert-until
     typing <- put typing, after-row:offset, cursor-row
     typing <- put typing, after-column:offset, cursor-column
@@ -165,9 +165,9 @@ before <insert-character-end> [
     break +done-adding-insert-operation:label
   }
   # if not, create a new operation
-  insert-from:address:duplex-list:character <- next cursor-before
-  insert-to:address:duplex-list:character <- next insert-from
-  op:address:operation <- new operation:type
+  insert-from:&:duplex-list:char <- next cursor-before
+  insert-to:&:duplex-list:char <- next insert-from
+  op:&:operation <- new operation:type
   *op <- merge 0/insert-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, 1/coalesce
   editor <- add-operation editor, op
   +done-adding-insert-operation
@@ -175,20 +175,20 @@ before <insert-character-end> [
 
 # enter operations never coalesce with typing before or after
 after <insert-enter-begin> [
-  cursor-row-before:number <- copy cursor-row
-  cursor-column-before:number <- copy cursor-column
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
-  cursor-before:address:duplex-list:character <- get *editor, before-cursor:offset
+  cursor-row-before:num <- copy cursor-row
+  cursor-column-before:num <- copy cursor-column
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
+  cursor-before:&:duplex-list:char <- get *editor, before-cursor:offset
 ]
 before <insert-enter-end> [
-  top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-row:offset
+  top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-row:offset
   # never coalesce
-  insert-from:address:duplex-list:character <- next cursor-before
-  before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-  insert-to:address:duplex-list:character <- next before-cursor
-  op:address:operation <- new operation:type
+  insert-from:&:duplex-list:char <- next cursor-before
+  before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+  insert-to:&:duplex-list:char <- next before-cursor
+  op:&:operation <- new operation:type
   *op <- merge 0/insert-operation, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, insert-from, insert-to, 0/never-coalesce
   editor <- add-operation editor, op
 ]
@@ -197,13 +197,13 @@ before <insert-enter-end> [
 # redo stack, because it's now obsolete.
 # Beware: since we're counting cursor moves as operations, this means just
 # moving the cursor can lose work on the undo stack.
-def add-operation editor:address:editor-data, op:address:operation -> editor:address:editor-data [
+def add-operation editor:&:editor-data, op:&:operation -> editor:&:editor-data [
   local-scope
   load-ingredients
-  undo:address:list:address:operation <- get *editor, undo:offset
+  undo:&:list:&:operation <- get *editor, undo:offset
   undo <- push op undo
   *editor <- put *editor, undo:offset, undo
-  redo:address:list:address:operation <- get *editor, redo:offset
+  redo:&:list:&:operation <- get *editor, redo:offset
   redo <- copy 0
   *editor <- put *editor, redo:offset, redo
   return editor/same-as-ingredient:0
@@ -211,19 +211,19 @@ def add-operation editor:address:editor-data, op:address:operation -> editor:add
 
 after <handle-undo> [
   {
-    typing:insert-operation, is-insert?:boolean <- maybe-convert *op, typing:variant
+    typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     break-unless is-insert?
-    start:address:duplex-list:character <- get typing, insert-from:offset
-    end:address:duplex-list:character <- get typing, insert-until:offset
+    start:&:duplex-list:char <- get typing, insert-from:offset
+    end:&:duplex-list:char <- get typing, insert-until:offset
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
-    before-cursor:address:duplex-list:character <- prev start
+    before-cursor:&:duplex-list:char <- prev start
     *editor <- put *editor, before-cursor:offset, before-cursor
     remove-between before-cursor, end
     cursor-row <- get typing, before-row:offset
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get typing, before-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get typing, before-top-of-screen:offset
+    top:&:duplex-list:char <- get typing, before-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
@@ -232,18 +232,18 @@ scenario editor-can-undo-typing-multiple [
   # create an editor and type multiple characters
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [012]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # all characters must be gone
   screen-should-contain [
@@ -258,13 +258,13 @@ scenario editor-can-undo-typing-multiple-2 [
   # create an editor with some text
   assume-screen 10/width, 5/height
   1:text <- new [a]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # type some characters
   assume-console [
     type [012]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .012a      .
@@ -276,7 +276,7 @@ scenario editor-can-undo-typing-multiple-2 [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # back to original text
   screen-should-contain [
@@ -290,7 +290,7 @@ scenario editor-can-undo-typing-multiple-2 [
     type [3]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -304,14 +304,14 @@ scenario editor-can-undo-typing-enter [
   # create an editor with some text
   assume-screen 10/width, 5/height
   1:text <- new [  abc]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # new line
   assume-console [
     left-click 1, 8
     press enter
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .  abc     .
@@ -320,8 +320,8 @@ scenario editor-can-undo-typing-enter [
     .          .
   ]
   # line is indented
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 2
@@ -331,10 +331,10 @@ scenario editor-can-undo-typing-enter [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 5
@@ -351,7 +351,7 @@ scenario editor-can-undo-typing-enter [
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -367,13 +367,13 @@ scenario editor-redo-typing [
   # create an editor, type something, undo
   assume-screen 10/width, 5/height
   1:text <- new [a]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [012]
     press ctrl-z
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .a         .
@@ -385,7 +385,7 @@ scenario editor-redo-typing [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # all characters must be back
   screen-should-contain [
@@ -399,7 +399,7 @@ scenario editor-redo-typing [
     type [3]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -411,10 +411,10 @@ scenario editor-redo-typing [
 
 after <handle-redo> [
   {
-    typing:insert-operation, is-insert?:boolean <- maybe-convert *op, typing:variant
+    typing:insert-operation, is-insert?:bool <- maybe-convert *op, typing:variant
     break-unless is-insert?
     before-cursor <- get *editor, before-cursor:offset
-    insert-from:address:duplex-list:character <- get typing, insert-from:offset  # ignore insert-to because it's already been spliced away
+    insert-from:&:duplex-list:char <- get typing, insert-from:offset  # ignore insert-to because it's already been spliced away
     # assert insert-to matches next(before-cursor)
     insert-range before-cursor, insert-from
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
@@ -422,7 +422,7 @@ after <handle-redo> [
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get typing, after-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get typing, after-top-of-screen:offset
+    top:&:duplex-list:char <- get typing, after-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
@@ -431,13 +431,13 @@ scenario editor-redo-typing-empty [
   # create an editor, type something, undo
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [012]
     press ctrl-z
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .          .
@@ -449,7 +449,7 @@ scenario editor-redo-typing-empty [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # all characters must be back
   screen-should-contain [
@@ -463,7 +463,7 @@ scenario editor-redo-typing-empty [
     type [3]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -479,18 +479,18 @@ scenario editor-work-clears-redo-stack [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [1]
     press ctrl-z
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # do some more work
   assume-console [
     type [0]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .0abc      .
@@ -503,7 +503,7 @@ ghi]
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # nothing should happen
   screen-should-contain [
@@ -519,8 +519,8 @@ scenario editor-can-redo-typing-and-enter-and-tab [
   # create an editor
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and tabs, hit enter, some more text and tabs
   assume-console [
     press tab
@@ -531,7 +531,7 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press tab
     type [efg]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .  ab  cd  .
@@ -539,8 +539,8 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 7
@@ -550,11 +550,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # typing in second line deleted, but not indent
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 2
@@ -571,11 +571,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # indent and newline deleted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 8
@@ -591,11 +591,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # empty screen
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 0
@@ -611,11 +611,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 8
@@ -631,11 +631,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # newline and indent inserted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 2
@@ -652,11 +652,11 @@ scenario editor-can-redo-typing-and-enter-and-tab [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # indent and newline deleted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 7
@@ -678,21 +678,21 @@ scenario editor-can-undo-touch [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor
   assume-console [
     left-click 3, 1
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # click undone
   memory-should-contain [
@@ -704,7 +704,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -716,25 +716,25 @@ ghi]
 ]
 
 after <move-cursor-begin> [
-  cursor-row-before:number <- get *editor, cursor-row:offset
-  cursor-column-before:number <- get *editor, cursor-column:offset
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
+  cursor-row-before:num <- get *editor, cursor-row:offset
+  cursor-column-before:num <- get *editor, cursor-column:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
 ]
 before <move-cursor-end> [
-  top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-  cursor-row:number <- get *editor, cursor-row:offset
-  cursor-column:number <- get *editor, cursor-column:offset
+  top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+  cursor-row:num <- get *editor, cursor-row:offset
+  cursor-column:num <- get *editor, cursor-column:offset
   {
     break-unless undo-coalesce-tag
     # if previous operation was also a move, and also had the same coalesce
     # tag, coalesce with it
-    undo:address:list:address:operation <- get *editor, undo:offset
+    undo:&:list:&:operation <- get *editor, undo:offset
     break-unless undo
-    op:address:operation <- first undo
-    move:move-operation, is-move?:boolean <- maybe-convert *op, move:variant
+    op:&:operation <- first undo
+    move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
     break-unless is-move?
-    previous-coalesce-tag:number <- get move, tag:offset
-    coalesce?:boolean <- equal undo-coalesce-tag, previous-coalesce-tag
+    previous-coalesce-tag:num <- get move, tag:offset
+    coalesce?:bool <- equal undo-coalesce-tag, previous-coalesce-tag
     break-unless coalesce?
     move <- put move, after-row:offset, cursor-row
     move <- put move, after-column:offset, cursor-column
@@ -742,7 +742,7 @@ before <move-cursor-end> [
     *op <- merge 1/move-operation, move
     break +done-adding-move-operation:label
   }
-  op:address:operation <- new operation:type
+  op:&:operation <- new operation:type
   *op <- merge 1/move-operation, cursor-row-before, cursor-column-before, top-before, cursor-row/after, cursor-column/after, top-after, undo-coalesce-tag
   editor <- add-operation editor, op
   +done-adding-move-operation
@@ -750,14 +750,14 @@ before <move-cursor-end> [
 
 after <handle-undo> [
   {
-    move:move-operation, is-move?:boolean <- maybe-convert *op, move:variant
+    move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
     break-unless is-move?
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     cursor-row <- get move, before-row:offset
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get move, before-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get move, before-top-of-screen:offset
+    top:&:duplex-list:char <- get move, before-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
@@ -769,15 +769,15 @@ scenario editor-can-undo-scroll [
   1:text <- new [a
 b
 cdefgh]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 5/right
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 5/right
   # position cursor at end of screen and try to move right
   assume-console [
     left-click 3, 3
     press right-arrow
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   # screen scrolls
   screen-should-contain [
     .     .
@@ -794,9 +794,9 @@ cdefgh]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moved back
   memory-should-contain [
@@ -815,7 +815,7 @@ cdefgh]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .     .
@@ -831,22 +831,22 @@ scenario editor-can-undo-left-arrow [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor
   assume-console [
     left-click 3, 1
     press left-arrow
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -858,7 +858,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -875,16 +875,16 @@ scenario editor-can-undo-up-arrow [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor
   assume-console [
     left-click 3, 1
     press up-arrow
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 2
     4 <- 1
@@ -894,9 +894,9 @@ ghi]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -908,7 +908,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -925,22 +925,22 @@ scenario editor-can-undo-down-arrow [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor
   assume-console [
     left-click 2, 1
     press down-arrow
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -952,7 +952,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -972,21 +972,21 @@ c
 d
 e
 f]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # scroll the page
   assume-console [
     press ctrl-f
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen should again show page 1
   screen-should-contain [
@@ -1007,21 +1007,21 @@ c
 d
 e
 f]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # scroll the page
   assume-console [
     press page-down
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen should again show page 1
   screen-should-contain [
@@ -1042,22 +1042,22 @@ c
 d
 e
 f]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # scroll the page down and up
   assume-console [
     press page-down
     press ctrl-b
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen should again show page 2
   screen-should-contain [
@@ -1078,22 +1078,22 @@ c
 d
 e
 f]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # scroll the page down and up
   assume-console [
     press page-down
     press page-up
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen should again show page 2
   screen-should-contain [
@@ -1111,22 +1111,22 @@ scenario editor-can-undo-ctrl-a [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor, then to start of line
   assume-console [
     left-click 2, 1
     press ctrl-a
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -1138,7 +1138,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1155,22 +1155,22 @@ scenario editor-can-undo-home [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor, then to start of line
   assume-console [
     left-click 2, 1
     press home
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -1182,7 +1182,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1199,22 +1199,22 @@ scenario editor-can-undo-ctrl-e [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor, then to start of line
   assume-console [
     left-click 2, 1
     press ctrl-e
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -1226,7 +1226,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1243,22 +1243,22 @@ scenario editor-can-undo-end [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor, then to start of line
   assume-console [
     left-click 2, 1
     press end
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # undo
   assume-console [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves back
   memory-should-contain [
@@ -1270,7 +1270,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1287,8 +1287,8 @@ scenario editor-can-undo-multiple-arrows-in-the-same-direction [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # move the cursor
   assume-console [
     left-click 2, 1
@@ -1296,9 +1296,9 @@ ghi]
     press right-arrow
     press up-arrow
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 3
@@ -1308,9 +1308,9 @@ ghi]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # up-arrow is undone
   memory-should-contain [
@@ -1322,9 +1322,9 @@ ghi]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # both right-arrows are undone
   memory-should-contain [
@@ -1341,21 +1341,21 @@ scenario editor-redo-touch [
   1:text <- new [abc
 def
 ghi]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     left-click 3, 1
     press ctrl-z
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   # redo
   assume-console [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves to left-click
   memory-should-contain [
@@ -1367,7 +1367,7 @@ ghi]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1380,14 +1380,14 @@ ghi]
 
 after <handle-redo> [
   {
-    move:move-operation, is-move?:boolean <- maybe-convert *op, move:variant
+    move:move-operation, is-move?:bool <- maybe-convert *op, move:variant
     break-unless is-move?
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     cursor-row <- get move, after-row:offset
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get move, after-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get move, after-top-of-screen:offset
+    top:&:duplex-list:char <- get move, after-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
@@ -1396,16 +1396,16 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
   # create an editor, type some text, move the cursor, type some more text
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   assume-console [
     type [abc]
     left-click 1, 1
     type [d]
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   screen-should-contain [
     .          .
     .adbc      .
@@ -1421,9 +1421,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # last letter typed is deleted
   screen-should-contain [
@@ -1441,9 +1441,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # no change to screen; cursor moves
   screen-should-contain [
@@ -1461,9 +1461,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # screen empty
   screen-should-contain [
@@ -1481,9 +1481,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # first insert
   screen-should-contain [
@@ -1501,9 +1501,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # cursor moves
   screen-should-contain [
@@ -1522,9 +1522,9 @@ scenario editor-separates-undo-insert-from-undo-cursor-move [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
-    3:number <- get *2:address:editor-data, cursor-row:offset
-    4:number <- get *2:address:editor-data, cursor-column:offset
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
+    3:num <- get *2:&:editor-data, cursor-row:offset
+    4:num <- get *2:&:editor-data, cursor-column:offset
   ]
   # second insert
   screen-should-contain [
@@ -1545,23 +1545,23 @@ scenario editor-can-undo-and-redo-backspace [
   # create an editor
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and hit backspace
   assume-console [
     type [abc]
     press backspace
     press backspace
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .a         .
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1571,10 +1571,10 @@ scenario editor-can-undo-and-redo-backspace [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 3
@@ -1590,10 +1590,10 @@ scenario editor-can-undo-and-redo-backspace [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1608,27 +1608,27 @@ scenario editor-can-undo-and-redo-backspace [
 
 # save operation to undo
 after <backspace-character-begin> [
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
 ]
 before <backspace-character-end> [
   {
     break-unless backspaced-cell  # backspace failed; don't add an undo operation
-    top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-    cursor-row:number <- get *editor, cursor-row:offset
-    cursor-column:number <- get *editor, cursor-row:offset
-    before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-    undo:address:list:address:operation <- get *editor, undo:offset
+    top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+    cursor-row:num <- get *editor, cursor-row:offset
+    cursor-column:num <- get *editor, cursor-row:offset
+    before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+    undo:&:list:&:operation <- get *editor, undo:offset
     {
       # if previous operation was an insert, coalesce this operation with it
       break-unless undo
-      op:address:operation <- first undo
-      deletion:delete-operation, is-delete?:boolean <- maybe-convert *op, delete:variant
+      op:&:operation <- first undo
+      deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
       break-unless is-delete?
-      previous-coalesce-tag:number <- get deletion, tag:offset
-      coalesce?:boolean <- equal previous-coalesce-tag, 1/coalesce-backspace
+      previous-coalesce-tag:num <- get deletion, tag:offset
+      coalesce?:bool <- equal previous-coalesce-tag, 1/coalesce-backspace
       break-unless coalesce?
       deletion <- put deletion, delete-from:offset, before-cursor
-      backspaced-so-far:address:duplex-list:character <- get deletion, deleted-text:offset
+      backspaced-so-far:&:duplex-list:char <- get deletion, deleted-text:offset
       insert-range backspaced-cell, backspaced-so-far
       deletion <- put deletion, deleted-text:offset, backspaced-cell
       deletion <- put deletion, after-row:offset, cursor-row
@@ -1638,8 +1638,8 @@ before <backspace-character-end> [
       break +done-adding-backspace-operation:label
     }
     # if not, create a new operation
-    op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next before-cursor
+    op:&:operation <- new operation:type
+    deleted-until:&:duplex-list:char <- next before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, backspaced-cell/deleted, before-cursor/delete-from, deleted-until, 1/coalesce-backspace
     editor <- add-operation editor, op
     +done-adding-backspace-operation
@@ -1648,12 +1648,12 @@ before <backspace-character-end> [
 
 after <handle-undo> [
   {
-    deletion:delete-operation, is-delete?:boolean <- maybe-convert *op, delete:variant
+    deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
     break-unless is-delete?
-    anchor:address:duplex-list:character <- get deletion, delete-from:offset
+    anchor:&:duplex-list:char <- get deletion, delete-from:offset
     break-unless anchor
-    deleted:address:duplex-list:character <- get deletion, deleted-text:offset
-    old-cursor:address:duplex-list:character <- last deleted
+    deleted:&:duplex-list:char <- get deletion, deleted-text:offset
+    old-cursor:&:duplex-list:char <- last deleted
     insert-range anchor, deleted
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     before-cursor <- copy old-cursor
@@ -1661,25 +1661,25 @@ after <handle-undo> [
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get deletion, before-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get deletion, before-top-of-screen:offset
+    top:&:duplex-list:char <- get deletion, before-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
 
 after <handle-redo> [
   {
-    deletion:delete-operation, is-delete?:boolean <- maybe-convert *op, delete:variant
+    deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
     break-unless is-delete?
-    start:address:duplex-list:character <- get deletion, delete-from:offset
-    end:address:duplex-list:character <- get deletion, delete-until:offset
-    data:address:duplex-list:character <- get *editor, data:offset
+    start:&:duplex-list:char <- get deletion, delete-from:offset
+    end:&:duplex-list:char <- get deletion, delete-until:offset
+    data:&:duplex-list:char <- get *editor, data:offset
     remove-between start, end
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     cursor-row <- get deletion, after-row:offset
     *editor <- put *editor, cursor-row:offset, cursor-row
     cursor-column <- get deletion, after-column:offset
     *editor <- put *editor, cursor-column:offset, cursor-column
-    top:address:duplex-list:character <- get deletion, before-top-of-screen:offset
+    top:&:duplex-list:char <- get deletion, before-top-of-screen:offset
     *editor <- put *editor, top-of-screen:offset, top
   }
 ]
@@ -1690,8 +1690,8 @@ scenario editor-can-undo-and-redo-delete [
   # create an editor
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and hit delete and backspace a few times
   assume-console [
     type [abcdef]
@@ -1701,15 +1701,15 @@ scenario editor-can-undo-and-redo-delete [
     press delete
     press delete
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .af        .
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1719,10 +1719,10 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1738,10 +1738,10 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 2
@@ -1757,10 +1757,10 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 2
@@ -1776,11 +1776,11 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 2
@@ -1796,11 +1796,11 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1816,11 +1816,11 @@ scenario editor-can-undo-and-redo-delete [
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1834,28 +1834,28 @@ scenario editor-can-undo-and-redo-delete [
 ]
 
 after <delete-character-begin> [
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
 ]
 before <delete-character-end> [
   {
     break-unless deleted-cell  # delete failed; don't add an undo operation
-    top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-    cursor-row:number <- get *editor, cursor-row:offset
-    cursor-column:number <- get *editor, cursor-column:offset
-    before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-    undo:address:list:address:operation <- get *editor, undo:offset
+    top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+    cursor-row:num <- get *editor, cursor-row:offset
+    cursor-column:num <- get *editor, cursor-column:offset
+    before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+    undo:&:list:&:operation <- get *editor, undo:offset
     {
       # if previous operation was an insert, coalesce this operation with it
       break-unless undo
-      op:address:operation <- first undo
-      deletion:delete-operation, is-delete?:boolean <- maybe-convert *op, delete:variant
+      op:&:operation <- first undo
+      deletion:delete-operation, is-delete?:bool <- maybe-convert *op, delete:variant
       break-unless is-delete?
-      previous-coalesce-tag:number <- get deletion, tag:offset
-      coalesce?:boolean <- equal previous-coalesce-tag, 2/coalesce-delete
+      previous-coalesce-tag:num <- get deletion, tag:offset
+      coalesce?:bool <- equal previous-coalesce-tag, 2/coalesce-delete
       break-unless coalesce?
-      delete-until:address:duplex-list:character <- next before-cursor
+      delete-until:&:duplex-list:char <- next before-cursor
       deletion <- put deletion, delete-until:offset, delete-until
-      deleted-so-far:address:duplex-list:character <- get deletion, deleted-text:offset
+      deleted-so-far:&:duplex-list:char <- get deletion, deleted-text:offset
       deleted-so-far <- append deleted-so-far, deleted-cell
       deletion <- put deletion, deleted-text:offset, deleted-so-far
       deletion <- put deletion, after-row:offset, cursor-row
@@ -1865,8 +1865,8 @@ before <delete-character-end> [
       break +done-adding-delete-operation:label
     }
     # if not, create a new operation
-    op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next before-cursor
+    op:&:operation <- new operation:type
+    deleted-until:&:duplex-list:char <- next before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cell/deleted, before-cursor/delete-from, deleted-until, 2/coalesce-delete
     editor <- add-operation editor, op
     +done-adding-delete-operation
@@ -1880,14 +1880,14 @@ scenario editor-can-undo-and-redo-ctrl-k [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and hit delete and backspace a few times
   assume-console [
     left-click 1, 1
     press ctrl-k
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .a         .
@@ -1895,8 +1895,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1906,7 +1906,7 @@ def]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1915,8 +1915,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1926,7 +1926,7 @@ def]
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
   screen-should-contain [
@@ -1936,8 +1936,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 1
@@ -1947,7 +1947,7 @@ def]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -1959,16 +1959,16 @@ def]
 ]
 
 after <delete-to-end-of-line-begin> [
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
 ]
 before <delete-to-end-of-line-end> [
   {
     break-unless deleted-cells  # delete failed; don't add an undo operation
-    top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-    cursor-row:number <- get *editor, cursor-row:offset
-    cursor-column:number <- get *editor, cursor-column:offset
-    deleted-until:address:duplex-list:character <- next before-cursor
-    op:address:operation <- new operation:type
+    top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+    cursor-row:num <- get *editor, cursor-row:offset
+    cursor-column:num <- get *editor, cursor-column:offset
+    deleted-until:&:duplex-list:char <- next before-cursor
+    op:&:operation <- new operation:type
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, 0/never-coalesce
     editor <- add-operation editor, op
     +done-adding-delete-operation
@@ -1982,14 +1982,14 @@ scenario editor-can-undo-and-redo-ctrl-u [
   assume-screen 10/width, 5/height
   1:text <- new [abc
 def]
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and hit delete and backspace a few times
   assume-console [
     left-click 1, 2
     press ctrl-u
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .c         .
@@ -1997,8 +1997,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 0
@@ -2008,7 +2008,7 @@ def]
     press ctrl-z
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2017,8 +2017,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 2
@@ -2028,7 +2028,7 @@ def]
     press ctrl-y
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   # first line inserted
   screen-should-contain [
@@ -2038,8 +2038,8 @@ def]
     .┈┈┈┈┈┈┈┈┈┈.
     .          .
   ]
-  3:number <- get *2:address:editor-data, cursor-row:offset
-  4:number <- get *2:address:editor-data, cursor-column:offset
+  3:num <- get *2:&:editor-data, cursor-row:offset
+  4:num <- get *2:&:editor-data, cursor-column:offset
   memory-should-contain [
     3 <- 1
     4 <- 0
@@ -2049,7 +2049,7 @@ def]
     type [1]
   ]
   run [
-    editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   ]
   screen-should-contain [
     .          .
@@ -2061,17 +2061,17 @@ def]
 ]
 
 after <delete-to-start-of-line-begin> [
-  top-before:address:duplex-list:character <- get *editor, top-of-screen:offset
+  top-before:&:duplex-list:char <- get *editor, top-of-screen:offset
 ]
 before <delete-to-start-of-line-end> [
   {
     break-unless deleted-cells  # delete failed; don't add an undo operation
-    top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
-    op:address:operation <- new operation:type
-    before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset
-    deleted-until:address:duplex-list:character <- next before-cursor
-    cursor-row:number <- get *editor, cursor-row:offset
-    cursor-column:number <- get *editor, cursor-column:offset
+    top-after:&:duplex-list:char <- get *editor, top-of-screen:offset
+    op:&:operation <- new operation:type
+    before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
+    deleted-until:&:duplex-list:char <- next before-cursor
+    cursor-row:num <- get *editor, cursor-row:offset
+    cursor-column:num <- get *editor, cursor-column:offset
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, cursor-row/after, cursor-column/after, top-after, deleted-cells/deleted, before-cursor/delete-from, deleted-until, 0/never-coalesce
     editor <- add-operation editor, op
     +done-adding-delete-operation
@@ -2082,15 +2082,15 @@ scenario editor-can-undo-and-redo-ctrl-u-2 [
   # create an editor
   assume-screen 10/width, 5/height
   1:text <- new []
-  2:address:editor-data <- new-editor 1:text, screen:address:screen, 0/left, 10/right
-  editor-render screen, 2:address:editor-data
+  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  editor-render screen, 2:&:editor-data
   # insert some text and hit delete and backspace a few times
   assume-console [
     type [abc]
     press ctrl-u
     press ctrl-z
   ]
-  editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data
+  editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
   screen-should-contain [
     .          .
     .abc       .