1880 - switch .mu files to new type-deducing idiom

8 files changed, 978 insertions, 980 deletions

diff --git a/callcc.mu b/callcc.mu
index 5e8661bb..1bf32973 100644
--- a/callcc.mu
+++ b/callcc.mu
@@ -2,16 +2,16 @@
 
 recipe main [
   c:continuation <- f
-  continue-from c:continuation            # <-- ..when you hit this
+  continue-from c                         # <-- ..when you hit this
 ]
 
 recipe f [
   c:continuation <- g
-  reply c:continuation
+  reply c
 ]
 
 recipe g [
   c:continuation <- current-continuation  # <-- loop back to here
   $print 1
-  reply c:continuation  # threaded through unmodified after first iteration
+  reply c  # threaded through unmodified after first iteration
 ]
diff --git a/channel.mu b/channel.mu
index eb5b9641..ffa6d9f6 100644
--- a/channel.mu
+++ b/channel.mu
@@ -7,13 +7,13 @@ recipe producer [
   # n = 0
   n:number <- copy 0
   {
-    done?:boolean <- lesser-than n:number, 5
-    break-unless done?:boolean
+    done?:boolean <- lesser-than n, 5
+    break-unless done?
     # other threads might get between these prints
-    $print [produce: ], n:number, [ 
+    $print [produce: ], n, [ 
 ]
-    chan:address:channel <- write chan:address:channel, n:number
-    n:number <- add n:number, 1
+    chan:address:channel <- write chan, n
+    n <- add n, 1
     loop
   }
 ]
@@ -24,7 +24,7 @@ recipe consumer [
   chan:address:channel <- next-ingredient
   {
     # read an integer from the channel
-    n:number, chan:address:channel <- read chan:address:channel
+    n:number, chan:address:channel <- read chan
     # other threads might get between these prints
     $print [consume: ], n:number, [ 
 ]
@@ -36,8 +36,8 @@ recipe main [
   local-scope
   chan:address:channel <- new-channel 3
   # create two background 'routines' that communicate by a channel
-  routine1:number <- start-running producer:recipe, chan:address:channel
-  routine2:number <- start-running consumer:recipe, chan:address:channel
-  wait-for-routine routine1:number
-  wait-for-routine routine2:number
+  routine1:number <- start-running producer:recipe, chan
+  routine2:number <- start-running consumer:recipe, chan
+  wait-for-routine routine1
+  wait-for-routine routine2
 ]
diff --git a/chessboard.mu b/chessboard.mu
index 12c13417..d70c0544 100644
--- a/chessboard.mu
+++ b/chessboard.mu
@@ -38,7 +38,7 @@ scenario print-board-and-read-move [
 #?     $browse-trace #? 1
 #?     $close-trace #? 1
     # icon for the cursor
-    screen:address <- print-character screen:address, 9251/␣
+    screen <- print-character screen, 9251/␣
   ]
   screen-should-contain [
   #            1         2         3         4         5         6         7         8         9         10        11
@@ -74,39 +74,39 @@ recipe chessboard [
   local-scope
   screen:address <- next-ingredient
   console:address <- next-ingredient
-#?   $print [screen: ], screen:address, [, console: ], console:address, 10/newline
+#?   $print [screen: ], screen, [, console: ], console, 10/newline
   board:address:array:address:array:character <- initial-position
   # hook up stdin
   stdin:address:channel <- new-channel 10/capacity
-  start-running send-keys-to-channel:recipe, console:address, stdin:address:channel, screen:address
+  start-running send-keys-to-channel:recipe, console, stdin, screen
   # buffer lines in stdin
   buffered-stdin:address:channel <- new-channel 10/capacity
-  start-running buffer-lines:recipe, stdin:address:channel, buffered-stdin:address:channel
+  start-running buffer-lines:recipe, stdin, buffered-stdin
   {
     msg:address:array:character <- new [Stupid text-mode chessboard. White pieces in uppercase; black pieces in lowercase. No checking for legal moves.
 ]
-    print-string screen:address, msg:address:array:character
-    cursor-to-next-line screen:address
-    print-board screen:address, board:address:array:address:array:character
-    cursor-to-next-line screen:address
-    msg:address:array:character <- new [Type in your move as <from square>-<to square>. For example: 'a2-a4'. Then press <enter>.
+    print-string screen, msg
+    cursor-to-next-line screen
+    print-board screen, board
+    cursor-to-next-line screen
+    msg <- new [Type in your move as <from square>-<to square>. For example: 'a2-a4'. Then press <enter>.
 ]
-    print-string screen:address, msg:address:array:character
-    cursor-to-next-line screen:address
-    msg:address:array:character <- new [Hit 'q' to exit.
+    print-string screen, msg
+    cursor-to-next-line screen
+    msg <- new [Hit 'q' to exit.
 ]
-    print-string screen:address, msg:address:array:character
+    print-string screen, msg
     {
-      cursor-to-next-line screen:address
-      msg:address:array:character <- new [move: ]
-      print-string screen:address, msg:address:array:character
-      m:address:move, quit:boolean, error:boolean <- read-move buffered-stdin:address:channel, screen:address
-      break-if quit:boolean, +quit:offset
-      buffered-stdin:address:channel <- clear-channel buffered-stdin:address:channel  # cleanup after error. todo: test this?
-      loop-if error:boolean
+      cursor-to-next-line screen
+      msg <- new [move: ]
+      print-string screen, msg
+      m:address:move, quit:boolean, error:boolean <- read-move buffered-stdin, screen
+      break-if quit, +quit:label
+      buffered-stdin <- clear-channel buffered-stdin  # cleanup after error. todo: test this?
+      loop-if error
     }
-    board:address:array:address:array:character <- make-move board:address:array:address:array:character, m:address:move
-    clear-screen screen:address
+    board <- make-move board, m
+    clear-screen screen
     loop
   }
   +quit
@@ -118,40 +118,40 @@ recipe new-board [
   local-scope
   initial-position:address:array:number <- next-ingredient
   # assert(length(initial-position) == 64)
-  len:number <- length initial-position:address:array:number/lookup
-  correct-length?:boolean <- equal len:number, 64
-  assert correct-length?:boolean, [chessboard had incorrect size]
+  len:number <- length *initial-position
+  correct-length?:boolean <- equal len, 64
+  assert correct-length?, [chessboard had incorrect size]
   # board is an array of pointers to files; file is an array of characters
   board:address:array:address:array:character <- new location:type, 8
   col:number <- copy 0
   {
-    done?:boolean <- equal col:number, 8
-    break-if done?:boolean
-    file:address:address:array:character <- index-address board:address:array:address:array:character/lookup, col:number
-    file:address:address:array:character/lookup <- new-file initial-position:address:array:number, col:number
-    col:number <- add col:number, 1
+    done?:boolean <- equal col, 8
+    break-if done?
+    file:address:address:array:character <- index-address *board, col
+    *file <- new-file initial-position, col
+    col <- add col, 1
     loop
   }
-  reply board:address:array:address:array:character
+  reply board
 ]
 
 recipe new-file [
   local-scope
   position:address:array:number <- next-ingredient
   index:number <- next-ingredient
-  index:number <- multiply index:number, 8
+  index <- multiply index, 8
   result:address:array:character <- new character:type, 8
   row:number <- copy 0
   {
-    done?:boolean <- equal row:number, 8
-    break-if done?:boolean
-    dest:address:character <- index-address result:address:array:character/lookup, row:number
-    dest:address:character/lookup <- index position:address:array:number/lookup, index:number
-    row:number <- add row:number, 1
-    index:number <- add index:number, 1
+    done?:boolean <- equal row, 8
+    break-if done?
+    dest:address:character <- index-address *result, row
+    *dest <- index *position, index
+    row <- add row, 1
+    index <- add index, 1
     loop
   }
-  reply result:address:array:character
+  reply result
 ]
 
 recipe print-board [
@@ -160,42 +160,42 @@ recipe print-board [
   board:address:array:address:array:character <- next-ingredient
   row:number <- copy 7  # start printing from the top of the board
   # print each row
-#?   $print [printing board to screen ], screen:address, 10/newline
+#?   $print [printing board to screen ], screen, 10/newline
   {
-    done?:boolean <- lesser-than row:number, 0
-    break-if done?:boolean
-#?     $print [printing rank ], row:number, 10/newline
+    done?:boolean <- lesser-than row, 0
+    break-if done?
+#?     $print [printing rank ], row, 10/newline
     # print rank number as a legend
-    rank:number <- add row:number, 1
-    print-integer screen:address, rank:number
+    rank:number <- add row, 1
+    print-integer screen, rank
     s:address:array:character <- new [ | ]
-    print-string screen:address, s:address:array:character
+    print-string screen, s
     # print each square in the row
     col:number <- copy 0
     {
       done?:boolean <- equal col:number, 8
       break-if done?:boolean
-      f:address:array:character <- index board:address:array:address:array:character/lookup, col:number
-      c:character <- index f:address:array:character/lookup, row:number
-      print-character screen:address, c:character
-      print-character screen:address, 32/space
-      col:number <- add col:number, 1
+      f:address:array:character <- index *board, col
+      c:character <- index *f, row
+      print-character screen, c
+      print-character screen, 32/space
+      col <- add col, 1
       loop
     }
-    row:number <- subtract row:number, 1
-    cursor-to-next-line screen:address
+    row <- subtract row, 1
+    cursor-to-next-line screen
     loop
   }
   # print file letters as legend
 #?   $print [printing legend
 #? ] #? 1
-  s:address:array:character <- new [  +----------------]
-  print-string screen:address, s:address:array:character
-  screen:address <- cursor-to-next-line screen:address
-#?   screen:address <- print-character screen:address, 97 #? 1
-  s:address:array:character <- new [    a b c d e f g h]
-  screen:address <- print-string screen:address, s:address:array:character
-  screen:address <- cursor-to-next-line screen:address
+  s <- new [  +----------------]
+  print-string screen, s
+  screen <- cursor-to-next-line screen
+#?   screen <- print-character screen, 97 #? 1
+  s <- new [    a b c d e f g h]
+  screen <- print-string screen, s
+  screen <- cursor-to-next-line screen
 #?   $print [done printing board
 #? ] #? 1
 ]
@@ -221,8 +221,8 @@ recipe initial-position [
 #?       66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b,
 #?       78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n,
 #?       82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r
-  board:address:array:address:array:character <- new-board initial-position:address:array:number
-  reply board:address:array:address:array:character
+  board:address:array:address:array:character <- new-board initial-position
+  reply board
 ]
 
 scenario printing-the-board [
@@ -266,32 +266,32 @@ recipe read-move [
   stdin:address:channel <- next-ingredient
   screen:address <- next-ingredient
 #?   $print screen:address #? 1
-  from-file:number, quit?:boolean, error?:boolean <- read-file stdin:address:channel, screen:address
-  reply-if quit?:boolean, 0/dummy, quit?:boolean, error?:boolean
-  reply-if error?:boolean, 0/dummy, quit?:boolean, error?:boolean
+  from-file:number, quit?:boolean, error?:boolean <- read-file stdin, screen
+  reply-if quit?, 0/dummy, quit?, error?
+  reply-if error?, 0/dummy, quit?, error?
 #?   close-console #? 1
   # construct the move object
   result:address:move <- new move:type
-  x:address:number <- get-address result:address:move/lookup, from-file:offset
-  x:address:number/lookup <- copy from-file:number
-  x:address:number <- get-address result:address:move/lookup, from-rank:offset
-  x:address:number/lookup, quit?:boolean, error?:boolean <- read-rank stdin:address:channel, screen:address
-  reply-if quit?:boolean, 0/dummy, quit?:boolean, error?:boolean
-  reply-if error?:boolean, 0/dummy, quit?:boolean, error?:boolean
-  error?:boolean <- expect-from-channel stdin:address:channel, 45/dash, screen:address
-  reply-if error?:boolean, 0/dummy, 0/quit, error?:boolean
-  x:address:number <- get-address result:address:move/lookup, to-file:offset
-  x:address:number/lookup, quit?:boolean, error?:boolean <- read-file stdin:address:channel, screen:address
-  reply-if quit?:boolean, 0/dummy, quit?:boolean, error?:boolean
-  reply-if error?:boolean, 0/dummy, quit?:boolean, error?:boolean
-  x:address:number <- get-address result:address:move/lookup, to-rank:offset
-  x:address:number/lookup, quit?:boolean, error?:boolean <- read-rank stdin:address:channel, screen:address
+  x:address:number <- get-address *result, from-file:offset
+  *x <- copy from-file
+  x <- get-address *result, from-rank:offset
+  *x, quit?, error? <- read-rank stdin, screen
+  reply-if quit?, 0/dummy, quit?, error?
+  reply-if error?, 0/dummy, quit?, error?
+  error? <- expect-from-channel stdin, 45/dash, screen
+  reply-if error?, 0/dummy, 0/quit, error?
+  x <- get-address *result, to-file:offset
+  *x, quit?, error? <- read-file stdin, screen
   reply-if quit?:boolean, 0/dummy, quit?:boolean, error?:boolean
   reply-if error?:boolean, 0/dummy, quit?:boolean, error?:boolean
+  x:address:number <- get-address *result, to-rank:offset
+  *x, quit?, error? <- read-rank stdin, screen
+  reply-if quit?, 0/dummy, quit?, error?
+  reply-if error?, 0/dummy, quit?, error?
 #?   $exit #? 1
-  error?:boolean <- expect-from-channel stdin:address:channel, 10/newline, screen:address
-  reply-if error?:boolean, 0/dummy, 0/quit, error?:boolean
-  reply result:address:move, quit?:boolean, error?:boolean
+  error? <- expect-from-channel stdin, 10/newline, screen
+  reply-if error?, 0/dummy, 0/quit, error?
+  reply result, quit?, error?
 ]
 
 # file:number, quit:boolean, error:boolean <- read-file stdin:address:channel, screen:address
@@ -300,50 +300,50 @@ recipe read-file [
   local-scope
   stdin:address:channel <- next-ingredient
   screen:address <- next-ingredient
-  c:character, stdin:address:channel <- read stdin:address:channel
+  c:character, stdin <- read stdin
   {
-    q-pressed?:boolean <- equal c:character, 81/Q
-    break-unless q-pressed?:boolean
+    q-pressed?:boolean <- equal c, 81/Q
+    break-unless q-pressed?
     reply 0/dummy, 1/quit, 0/error
   }
   {
-    q-pressed?:boolean <- equal c:character, 113/q
-    break-unless q-pressed?:boolean
+    q-pressed? <- equal c, 113/q
+    break-unless q-pressed?
     reply 0/dummy, 1/quit, 0/error
   }
   {
-    empty-fake-keyboard?:boolean <- equal c:character, 0/eof
-    break-unless empty-fake-keyboard?:boolean
+    empty-fake-keyboard?:boolean <- equal c, 0/eof
+    break-unless empty-fake-keyboard?
     reply 0/dummy, 1/quit, 0/error
   }
   {
-    newline?:boolean <- equal c:character, 10/newline
-    break-unless newline?:boolean
+    newline?:boolean <- equal c, 10/newline
+    break-unless newline?
     error-message:address:array:character <- new [that's not enough]
-    print-string screen:address, error-message:address:array:character
+    print-string screen, error-message
     reply 0/dummy, 0/quit, 1/error
   }
-  file:number <- subtract c:character, 97/a
-#?   $print file:number, 10/newline
+  file:number <- subtract c, 97/a
+#?   $print file, 10/newline
   # 'a' <= file <= 'h'
   {
-    above-min:boolean <- greater-or-equal file:number, 0
-    break-if above-min:boolean
+    above-min:boolean <- greater-or-equal file, 0
+    break-if above-min
     error-message:address:array:character <- new [file too low: ]
-    print-string screen:address, error-message:address:array:character
-    print-character screen:address, c:character
-    cursor-to-next-line screen:address
+    print-string screen, error-message
+    print-character screen, c
+    cursor-to-next-line screen
     reply 0/dummy, 0/quit, 1/error
   }
   {
-    below-max:boolean <- lesser-than file:number, 8
-    break-if below-max:boolean
-    error-message:address:array:character <- new [file too high: ]
-    print-string screen:address, error-message:address:array:character
-    print-character screen:address, c:character
+    below-max:boolean <- lesser-than file, 8
+    break-if below-max
+    error-message <- new [file too high: ]
+    print-string screen, error-message
+    print-character screen, c
     reply 0/dummy, 0/quit, 1/error
   }
-  reply file:number, 0/quit, 0/error
+  reply file, 0/quit, 0/error
 ]
 
 # rank:number <- read-rank stdin:address:channel, screen:address
@@ -352,44 +352,44 @@ recipe read-rank [
   local-scope
   stdin:address:channel <- next-ingredient
   screen:address <- next-ingredient
-  c:character, stdin:address:channel <- read stdin:address:channel
+  c:character, stdin <- read stdin
   {
-    q-pressed?:boolean <- equal c:character, 8/Q
-    break-unless q-pressed?:boolean
+    q-pressed?:boolean <- equal c, 8/Q
+    break-unless q-pressed?
     reply 0/dummy, 1/quit, 0/error
   }
   {
-    q-pressed?:boolean <- equal c:character, 113/q
-    break-unless q-pressed?:boolean
+    q-pressed? <- equal c, 113/q
+    break-unless q-pressed?
     reply 0/dummy, 1/quit, 0/error
   }
   {
-    newline?:boolean <- equal c:character, 10  # newline
-    break-unless newline?:boolean
+    newline?:boolean <- equal c, 10  # newline
+    break-unless newline?
     error-message:address:array:character <- new [that's not enough]
-    print-string screen:address, error-message:address:array:character
+    print-string screen, error-message
     reply 0/dummy, 0/quit, 1/error
   }
-  rank:number <- subtract c:character, 49/'1'
-#?   $print rank:number, 10/newline
+  rank:number <- subtract c, 49/'1'
+#?   $print rank, 10/newline
   # assert'1' <= rank <= '8'
   {
-    above-min:boolean <- greater-or-equal rank:number, 0
-    break-if above-min:boolean
-    error-message:address:array:character <- new [rank too low: ]
-    print-string screen:address, error-message:address:array:character
-    print-character screen:address, c:character
+    above-min:boolean <- greater-or-equal rank, 0
+    break-if above-min
+    error-message <- new [rank too low: ]
+    print-string screen, error-message
+    print-character screen, c
     reply 0/dummy, 0/quit, 1/error
   }
   {
-    below-max:boolean <- lesser-or-equal rank:number, 7
-    break-if below-max:boolean
-    error-message:address:array:character <- new [rank too high: ]
-    print-string screen:address, error-message:address:array:character
-    print-character screen:address, c:character
+    below-max:boolean <- lesser-or-equal rank, 7
+    break-if below-max
+    error-message <- new [rank too high: ]
+    print-string screen, error-message
+    print-character screen, c
     reply 0/dummy, 0/quit, 1/error
   }
-  reply rank:number, 0/quit, 0/error
+  reply rank, 0/quit, 0/error
 ]
 
 # read a character from the given channel and check that it's what we expect
@@ -399,15 +399,15 @@ recipe expect-from-channel [
   stdin:address:channel <- next-ingredient
   expected:character <- next-ingredient
   screen:address <- next-ingredient
-  c:character, stdin:address:channel <- read stdin:address:channel
-  match?:boolean <- equal c:character, expected:character
+  c:character, stdin <- read stdin
   {
-    break-if match?:boolean
+    match?:boolean <- equal c, expected
+    break-if match?
     s:address:array:character <- new [expected character not found]
-    print-string screen:address, s:address:array:character
+    print-string screen, s
   }
-  result:boolean <- not match?:boolean
-  reply result:boolean
+  result:boolean <- not match?
+  reply result
 ]
 
 scenario read-move-blocking [
@@ -590,22 +590,22 @@ recipe make-move [
   local-scope
   b:address:array:address:array:character <- next-ingredient
   m:address:move <- next-ingredient
-  from-file:number <- get m:address:move/lookup, from-file:offset
-#?   $print from-file:number, 10/newline
-  from-rank:number <- get m:address:move/lookup, from-rank:offset
-#?   $print from-rank:number, 10/newline
-  to-file:number <- get m:address:move/lookup, to-file:offset
-#?   $print to-file:number, 10/newline
-  to-rank:number <- get m:address:move/lookup, to-rank:offset
-#?   $print to-rank:number, 10/newline
-  f:address:array:character <- index b:address:array:address:array:character/lookup, from-file:number
-  src:address:character/square <- index-address f:address:array:character/lookup, from-rank:number
-  f:address:array:character <- index b:address:array:address:array:character/lookup, to-file:number
-  dest:address:character/square <- index-address f:address:array:character/lookup, to-rank:number
-#?   $print src:address:character/lookup, 10/newline
-  dest:address:character/lookup/square <- copy src:address:character/lookup/square
-  src:address:character/lookup/square <- copy 32/space
-  reply b:address:array:address:array:character/same-as-ingredient:0
+  from-file:number <- get *m, from-file:offset
+#?   $print from-file, 10/newline
+  from-rank:number <- get *m, from-rank:offset
+#?   $print from-rank, 10/newline
+  to-file:number <- get *m, to-file:offset
+#?   $print to-file, 10/newline
+  to-rank:number <- get *m, to-rank:offset
+#?   $print to-rank, 10/newline
+  f:address:array:character <- index *b, from-file
+  src:address:character/square <- index-address *f, from-rank
+  f <- index *b, to-file
+  dest:address:character/square <- index-address *f, to-rank
+#?   $print *src, 10/newline
+  *dest <- copy *src
+  *src <- copy 32/space
+  reply b/same-as-ingredient:0
 ]
 
 scenario making-a-move [
@@ -613,14 +613,14 @@ scenario making-a-move [
   run [
     2:address:array:address:array:character/board <- initial-position
     3:address:move <- new move:type
-    4:address:number <- get-address 3:address:move/lookup, from-file:offset
-    4:address:number/lookup <- copy 6/g
-    5:address:number <- get-address 3:address:move/lookup, from-rank:offset
-    5:address:number/lookup <- copy 1/'2'
-    6:address:number <- get-address 3:address:move/lookup, to-file:offset
-    6:address:number/lookup <- copy 6/g
-    7:address:number <- get-address 3:address:move/lookup, to-rank:offset
-    7:address:number/lookup <- copy 3/'4'
+    4:address:number <- get-address *3:address:move, from-file:offset
+    *4:address:number <- copy 6/g
+    5:address:number <- get-address *3:address:move, from-rank:offset
+    *5:address:number <- copy 1/'2'
+    6:address:number <- get-address *3:address:move, to-file:offset
+    *6:address:number <- copy 6/g
+    7:address:number <- get-address *3:address:move, to-rank:offset
+    *7:address:number <- copy 3/'4'
     2:address:array:address:array:character/board <- make-move 2:address:array:address:array:character/board, 3:address:move
     screen:address <- print-board screen:address, 2:address:array:address:array:character/board
   ]
diff --git a/console.mu b/console.mu
index 0dd59212..a1bda1bc 100644
--- a/console.mu
+++ b/console.mu
@@ -6,7 +6,7 @@ recipe main [
   open-console
   {
     _, found?:boolean <- check-for-interaction
-    break-if found?:boolean
+    break-if found?
     print-character-to-display 97, 7/white
     loop
   }
diff --git a/counters.mu b/counters.mu
index 6428ff9b..be1f098a 100644
--- a/counters.mu
+++ b/counters.mu
@@ -4,14 +4,14 @@
 recipe new-counter [
   default-space:address:array:location <- new location:type, 30
   n:number <- next-ingredient
-  reply default-space:address:array:location
+  reply default-space
 ]
 
 recipe increment-counter [
   local-scope
   0:address:array:location/names:new-counter <- next-ingredient  # setup outer space; it *must* come from 'new-counter'
   x:number <- next-ingredient
-  n:number/space:1 <- add n:number/space:1, x:number
+  n:number/space:1 <- add n:number/space:1, x
   reply n:number/space:1
 ]
 
@@ -22,13 +22,13 @@ recipe main [
   # counter B
   b:address:array:location <- new-counter 23
   # increment both by 2 but in different ways
-  increment-counter a:address:array:location, 1
-  b-value:number <- increment-counter b:address:array:location, 2
-  a-value:number <- increment-counter a:address:array:location, 1
+  increment-counter a, 1
+  b-value:number <- increment-counter b, 2
+  a-value:number <- increment-counter a, 1
   # check results
   $print [Contents of counters
 ]
   # trailing space in next line is to help with syntax highlighting
-  $print [a: ], a-value:number, [ b: ], b-value:number, [ 
+  $print [a: ], a-value, [ b: ], b-value, [ 
 ]
 ]
diff --git a/edit.mu b/edit.mu
index a1e6408a..ae92a8d6 100644
--- a/edit.mu
+++ b/edit.mu
@@ -5,11 +5,11 @@ recipe main [
   open-console
   initial-recipe:address:array:character <- restore [recipes.mu]
   initial-sandbox:address:array:character <- new []
-  env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe:address:array:character, initial-sandbox:address:array:character
-  env:address:programming-environment-data <- restore-sandboxes env:address:programming-environment-data
-  render-all 0/screen, env:address:programming-environment-data
+  env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
+  env <- restore-sandboxes env
+  render-all 0/screen, env
   show-screen 0/screen
-  event-loop 0/screen, 0/console, env:address:programming-environment-data
+  event-loop 0/screen, 0/console, env
   # never gets here
 ]
 
@@ -26,30 +26,30 @@ recipe new-programming-environment [
   screen:address <- next-ingredient
   initial-recipe-contents:address:array:character <- next-ingredient
   initial-sandbox-contents:address:array:character <- next-ingredient
-  width:number <- screen-width screen:address
-  height:number <- screen-height screen:address
+  width:number <- screen-width screen
+  height:number <- screen-height screen
   # top menu
   result:address:programming-environment-data <- new programming-environment-data:type
-  draw-horizontal screen:address, 0, 0/left, width:number, 32/space, 0/black, 238/grey
-  button-start:number <- subtract width:number, 20
-  button-on-screen?:boolean <- greater-or-equal button-start:number, 0
-  assert button-on-screen?:boolean, [screen too narrow for menu]
-  move-cursor screen:address, 0/row, button-start:number/column
+  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
+  assert button-on-screen?, [screen too narrow for menu]
+  move-cursor screen, 0/row, button-start
   run-button:address:array:character <- new [ run (F4) ]
-  print-string screen:address, run-button:address:array:character, 255/white, 161/reddish
+  print-string screen, run-button, 255/white, 161/reddish
   # dotted line down the middle
-  divider:number, _ <- divide-with-remainder width:number, 2
-  draw-vertical screen:address, divider:number, 1/top, height:number, 9482/vertical-dotted
+  divider:number, _ <- divide-with-remainder width, 2
+  draw-vertical screen, divider, 1/top, height, 9482/vertical-dotted
   # recipe editor on the left
-  recipes:address:address:editor-data <- get-address result:address:programming-environment-data/lookup, recipes:offset
-  recipes:address:address:editor-data/lookup <- new-editor initial-recipe-contents:address:array:character, screen:address, 0/left, divider:number/right
+  recipes:address:address:editor-data <- get-address *result, recipes:offset
+  *recipes <- new-editor initial-recipe-contents, screen, 0/left, divider/right
   # sandbox editor on the right
-  new-left:number <- add divider:number, 1
-  new-right:number <- add new-left:number, 5
-  current-sandbox:address:address:editor-data <- get-address result:address:programming-environment-data/lookup, current-sandbox:offset
-  current-sandbox:address:address:editor-data/lookup <- new-editor initial-sandbox-contents:address:array:character, screen:address, new-left:number, width:number
-  screen:address <- render-all screen:address, result:address:programming-environment-data
-  reply result:address:programming-environment-data
+  new-left:number <- add divider, 1
+  new-right:number <- add new-left, 5
+  current-sandbox:address:address:editor-data <- get-address *result, current-sandbox:offset
+  *current-sandbox <- new-editor initial-sandbox-contents, screen, new-left, width/right
+  screen <- render-all screen, result
+  reply result
 ]
 
 scenario editor-initially-prints-string-to-screen [
@@ -94,52 +94,52 @@ recipe new-editor [
   # no clipping of bounds
   left:number <- next-ingredient
   right:number <- next-ingredient
-  right:number <- subtract right:number, 1
+  right <- subtract right, 1
   result:address:editor-data <- new editor-data:type
   # initialize screen-related fields
-  x:address:number <- get-address result:address:editor-data/lookup, left:offset
-  x:address:number/lookup <- copy left:number
-  x:address:number <- get-address result:address:editor-data/lookup, right:offset
-  x:address:number/lookup <- copy right:number
+  x:address:number <- get-address *result, left:offset
+  *x <- copy left
+  x <- get-address *result, right:offset
+  *x <- copy right
   # initialize cursor
-  x:address:number <- get-address result:address:editor-data/lookup, cursor-row:offset
-  x:address:number/lookup <- copy 1/top
-  x:address:number <- get-address result:address:editor-data/lookup, cursor-column:offset
-  x:address:number/lookup <- copy left:number
-  init:address:address:duplex-list <- get-address result:address:editor-data/lookup, data:offset
-  init:address:address:duplex-list/lookup <- push-duplex 167/§, 0/tail
-  y:address:address:duplex-list <- get-address result:address:editor-data/lookup, before-cursor:offset
-  y:address:address:duplex-list/lookup <- copy init:address:address:duplex-list/lookup
+  x <- get-address *result, cursor-row:offset
+  *x <- copy 1/top
+  x <- get-address *result, cursor-column:offset
+  *x <- copy left
+  init:address:address:duplex-list <- get-address *result, data:offset
+  *init <- push-duplex 167/§, 0/tail
+  y:address:address:duplex-list <- get-address *result, before-cursor:offset
+  *y <- copy *init
   # early exit if s is empty
-  reply-unless s:address:array:character, result:address:editor-data
-  len:number <- length s:address:array:character/lookup
-  reply-unless len:number, result:address:editor-data
+  reply-unless s, result
+  len:number <- length *s
+  reply-unless len, result
   idx:number <- copy 0
   # now we can start appending the rest, character by character
-  curr:address:duplex-list <- copy init:address:address:duplex-list/lookup
+  curr:address:duplex-list <- copy *init
   {
-    done?:boolean <- greater-or-equal idx:number, len:number
-    break-if done?:boolean
-    c:character <- index s:address:array:character/lookup, idx:number
-    insert-duplex c:character, curr:address:duplex-list
+    done?:boolean <- greater-or-equal idx, len
+    break-if done?
+    c:character <- index *s, idx
+    insert-duplex c, curr
     # next iter
-    curr:address:duplex-list <- next-duplex curr:address:duplex-list
-    idx:number <- add idx:number, 1
+    curr <- next-duplex curr
+    idx <- add idx, 1
     loop
   }
   # initialize cursor to top of screen
-  y:address:address:duplex-list <- get-address result:address:editor-data/lookup, before-cursor:offset
-  y:address:address:duplex-list/lookup <- copy init:address:address:duplex-list/lookup
+  y <- get-address *result, before-cursor:offset
+  *y <- copy *init
   # initial render to screen, just for some old tests
-  _, screen:address <- render screen:address, result:address:editor-data
-  reply result:address:editor-data
+  _, screen <- render screen, result
+  reply result
 ]
 
 scenario editor-initializes-without-data [
   assume-screen 5/width, 3/height
   run [
     1:address:editor-data <- new-editor 0/data, screen:address, 2/left, 5/right
-    2:editor-data <- copy 1:address:editor-data/lookup
+    2:editor-data <- copy *1:address:editor-data
   ]
   memory-should-contain [
     # 2 (data) <- just the § sentinel
@@ -161,108 +161,108 @@ recipe render [
   local-scope
   screen:address <- next-ingredient
   editor:address:editor-data <- next-ingredient
-  reply-unless editor:address:editor-data, 1/top, screen:address/same-as-ingredient:0
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  screen-height:number <- screen-height screen:address
-  right:number <- get editor:address:editor-data/lookup, right:offset
-  hide-screen screen:address
+  reply-unless editor, 1/top, screen/same-as-ingredient:0
+  left:number <- get *editor, left:offset
+  screen-height:number <- screen-height screen
+  right:number <- get *editor, right:offset
+  hide-screen screen
   # highlight mu code with color
   color:number <- copy 7/white
   highlighting-state:number <- copy 0/normal
   # traversing editor
-  curr:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
-  prev:address:duplex-list <- copy curr:address:duplex-list
-  curr:address:duplex-list <- next-duplex curr:address:duplex-list
+  curr:address:duplex-list <- get *editor, data:offset
+  prev:address:duplex-list <- copy curr
+  curr <- next-duplex curr
   # traversing screen
   row:number <- copy 1/top
-  column:number <- copy left:number
-  cursor-row:address:number <- get-address editor:address:editor-data/lookup, cursor-row:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  move-cursor screen:address, row:number, column:number
+  column:number <- copy left
+  cursor-row:address:number <- get-address *editor, cursor-row:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  move-cursor screen, row, column
   {
     +next-character
-    break-unless curr:address:duplex-list
-    off-screen?:boolean <- greater-or-equal row:number, screen-height:number
-    break-if off-screen?:boolean
+    break-unless curr
+    off-screen?:boolean <- 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:number, cursor-row:address:number/lookup
-      break-unless at-cursor-row?:boolean
-      at-cursor?:boolean <- equal column:number, cursor-column:address:number/lookup
-      break-unless at-cursor?:boolean
-      before-cursor:address:address:duplex-list/lookup <- prev-duplex curr:address:duplex-list
+      at-cursor-row?:boolean <- equal row, *cursor-row
+      break-unless at-cursor-row?
+      at-cursor?:boolean <- equal column, *cursor-column
+      break-unless at-cursor?
+      *before-cursor <- prev-duplex curr
     }
-    c:character <- get curr:address:duplex-list/lookup, value:offset
-    color:number, highlighting-state:number <- get-color color:number, highlighting-state:number, c:character
+    c:character <- get *curr, value:offset
+    color, highlighting-state <- get-color color, highlighting-state, c
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c:character, 10/newline
-      break-unless newline?:boolean
+      newline?:boolean <- equal c, 10/newline
+      break-unless newline?
       # adjust cursor if necessary
       {
-        at-cursor-row?:boolean <- equal row:number, cursor-row:address:number/lookup
-        break-unless at-cursor-row?:boolean
-        left-of-cursor?:boolean <- lesser-than column:number, cursor-column:address:number/lookup
-        break-unless left-of-cursor?:boolean
-        cursor-column:address:number/lookup <- copy column:number
-        before-cursor:address:address:duplex-list/lookup <- prev-duplex curr:address:duplex-list
+        at-cursor-row? <- equal row, *cursor-row
+        break-unless at-cursor-row?
+        left-of-cursor?:boolean <- lesser-than column, *cursor-column
+        break-unless left-of-cursor?
+        *cursor-column <- copy column
+        *before-cursor <- prev-duplex curr
       }
       # clear rest of line in this window
-      clear-line-delimited screen:address, column:number, right:number
+      clear-line-delimited screen, column, right
       # skip to next line
-      row:number <- add row:number, 1
-      column:number <- copy left:number
-      move-cursor screen:address, row:number, column:number
-      curr:address:duplex-list <- next-duplex curr:address:duplex-list
-      prev:address:duplex-list <- next-duplex prev:address:duplex-list
+      row <- add row, 1
+      column <- copy left
+      move-cursor screen, row, column
+      curr <- next-duplex curr
+      prev <- next-duplex prev
       loop +next-character:label
     }
     {
       # 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:number, right:number
-      break-unless at-right?:boolean
+      at-right?:boolean <- equal column, right
+      break-unless at-right?
       # print wrap icon
-      print-character screen:address, 8617/loop-back-to-left, 245/grey
-      column:number <- copy left:number
-      row:number <- add row:number, 1
-      move-cursor screen:address, row:number, column:number
+      print-character screen, 8617/loop-back-to-left, 245/grey
+      column <- copy left
+      row <- add row, 1
+      move-cursor screen, row, column
       # don't increment curr
       loop +next-character:label
     }
-    print-character screen:address, c:character, color:number
-    curr:address:duplex-list <- next-duplex curr:address:duplex-list
-    prev:address:duplex-list <- next-duplex prev:address:duplex-list
-    column:number <- add column:number, 1
+    print-character screen, c, color
+    curr <- next-duplex curr
+    prev <- next-duplex prev
+    column <- add column, 1
     loop
   }
   # is cursor to the right of the last line? move to end
   {
-    at-cursor-row?:boolean <- equal row:number, cursor-row:address:number/lookup
-    cursor-outside-line?:boolean <- lesser-or-equal column:number, cursor-column:address:number/lookup
-    before-cursor-on-same-line?:boolean <- and at-cursor-row?:boolean, cursor-outside-line?:boolean
-    above-cursor-row?:boolean <- lesser-than row:number, cursor-row:address:number/lookup
-    before-cursor?:boolean <- or before-cursor-on-same-line?:boolean, above-cursor-row?:boolean
-    break-unless before-cursor?:boolean
-    cursor-row:address:number/lookup <- copy row:number
-    cursor-column:address:number/lookup <- copy column:number
+    at-cursor-row? <- 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?
+    break-unless before-cursor?
+    *cursor-row <- copy row
+    *cursor-column <- copy column
     # line not wrapped but cursor outside bounds? wrap cursor
     {
-      too-far-right?:boolean <- greater-than cursor-column:address:number/lookup, right:number
-      break-unless too-far-right?:boolean
-      cursor-column:address:number/lookup <- copy left:number
-      cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
-      above-screen-bottom?:boolean <- lesser-than cursor-row:address:number/lookup, screen-height:number
-      assert above-screen-bottom?:boolean, [unimplemented: wrapping cursor past bottom of screen]
+      too-far-right?:boolean <- greater-than *cursor-column, right
+      break-unless too-far-right?
+      *cursor-column <- copy left
+      *cursor-row <- add *cursor-row, 1
+      above-screen-bottom?:boolean <- lesser-than *cursor-row, screen-height
+      assert above-screen-bottom?, [unimplemented: wrapping cursor past bottom of screen]
     }
-    before-cursor:address:address:duplex-list/lookup <- copy prev:address:duplex-list
+    *before-cursor <- copy prev
   }
   # clear rest of current line
-  clear-line-delimited screen:address, column:number, right:number
-  reply row:number, screen:address/same-as-ingredient:0
+  clear-line-delimited screen, column, right
+  reply row, screen/same-as-ingredient:0
 ]
 
 # row:number, screen:address <- render-string screen:address, s:address:array:character, left:number, right:number, color:number, row:number
@@ -277,62 +277,62 @@ recipe render-string [
   right:number <- next-ingredient
   color:number <- next-ingredient
   row:number <- next-ingredient
-  row:number <- add row:number, 1
-  reply-unless s:address:array:character, row:number/same-as-ingredient:5, screen:address/same-as-ingredient:0
-  column:number <- copy left:number
-  move-cursor screen:address, row:number, column:number
-  screen-height:number <- screen-height screen:address
+  row <- add row, 1
+  reply-unless s, row/same-as-ingredient:5, screen/same-as-ingredient:0
+  column:number <- copy left
+  move-cursor screen, row, column
+  screen-height:number <- screen-height screen
   i:number <- copy 0
-  len:number <- length s:address:array:character/lookup
+  len:number <- length *s
   {
     +next-character
-    done?:boolean <- greater-or-equal i:number, len:number
-    break-if done?:boolean
-    done?:boolean <- greater-or-equal row:number, screen-height:number
-    break-if done?:boolean
-    c:character <- index s:address:array:character/lookup, i:number
+    done?:boolean <- greater-or-equal i, len
+    break-if done?
+    done? <- greater-or-equal row, screen-height
+    break-if done?
+    c:character <- index *s, i
     {
       # at right? wrap.
-      at-right?:boolean <- equal column:number, right:number
-      break-unless at-right?:boolean
+      at-right?:boolean <- equal column, right
+      break-unless at-right?
       # print wrap icon
-      print-character screen:address, 8617/loop-back-to-left, 245/grey
-      column:number <- copy left:number
-      row:number <- add row:number, 1
-      move-cursor screen:address, row:number, column:number
+      print-character screen, 8617/loop-back-to-left, 245/grey
+      column <- copy left
+      row <- add row, 1
+      move-cursor screen, row, column
       loop +next-character:label  # retry i
     }
-    i:number <- add i:number, 1
+    i <- add i, 1
     {
       # newline? move to left rather than 0
-      newline?:boolean <- equal c:character, 10/newline
-      break-unless newline?:boolean
+      newline?:boolean <- equal c, 10/newline
+      break-unless newline?
       # clear rest of line in this window
       {
-        done?:boolean <- greater-than column:number, right:number
-        break-if done?:boolean
-        print-character screen:address, 32/space
-        column:number <- add column:number, 1
+        done? <- greater-than column, right
+        break-if done?
+        print-character screen, 32/space
+        column <- add column, 1
         loop
       }
-      row:number <- add row:number, 1
-      column:number <- copy left:number
-      move-cursor screen:address, row:number, column:number
+      row <- add row, 1
+      column <- copy left
+      move-cursor screen, row, column
       loop +next-character:label
     }
-    print-character screen:address, c:character, color:number
-    column:number <- add column:number, 1
+    print-character screen, c, color
+    column <- add column, 1
     loop
   }
   {
     # clear rest of current line
-    line-done?:boolean <- greater-than column:number, right:number
-    break-if line-done?:boolean
-    print-character screen:address, 32/space
-    column:number <- add column:number, 1
+    line-done?:boolean <- greater-than column, right
+    break-if line-done?
+    print-character screen, 32/space
+    column <- add column, 1
     loop
   }
-  reply row:number/same-as-ingredient:5, screen:address/same-as-ingredient:0
+  reply row/same-as-ingredient:5, screen/same-as-ingredient:0
 ]
 
 # row:number, screen:address <- render-screen screen:address, sandbox-screen:address, left:number, right:number, row:number
@@ -345,63 +345,63 @@ recipe render-screen [
   left:number <- next-ingredient
   right:number <- next-ingredient
   row:number <- next-ingredient
-  row:number <- add row:number, 1
-  reply-unless s:address:screen, row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
+  row <- add row, 1
+  reply-unless s, row/same-as-ingredient:4, screen/same-as-ingredient:0
   # print 'screen:'
   header:address:array:character <- new [screen:]
-  row:number <- subtract row:number, 1  # compensate for render-string below
-  row:number <- render-string screen:address, header:address:array:character, left:number, right:number, 245/grey, row:number
+  row <- subtract row, 1  # compensate for render-string below
+  row <- render-string screen, header, left, right, 245/grey, row
   # newline
-  row:number <- add row:number, 1
-  move-cursor screen:address, row:number, left:number
+  row <- add row, 1
+  move-cursor screen, row, left
   # start printing s
-  column:number <- copy left:number
-  s-width:number <- screen-width s:address:screen
-  s-height:number <- screen-height s:address:screen
-  buf:address:array:screen-cell <- get s:address:screen/lookup, data:offset
-  stop-printing:number <- add left:number, s-width:number, 3
-  max-column:number <- min stop-printing:number, right:number
+  column:number <- copy left
+  s-width:number <- screen-width s
+  s-height:number <- screen-height s
+  buf:address:array:screen-cell <- get *s, 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:address:array:screen-cell/lookup
-  screen-height:number <- screen-height screen:address
+  len:number <- length *buf
+  screen-height:number <- screen-height screen
   {
-    done?:boolean <- greater-or-equal i:number, len:number
-    break-if done?:boolean
-    done?:boolean <- greater-or-equal row:number, screen-height:number
-    break-if done?:boolean
-    column:number <- copy left:number
-    move-cursor screen:address, row:number, column:number
+    done?:boolean <- greater-or-equal i, len
+    break-if done?
+    done? <- greater-or-equal row, screen-height
+    break-if done?
+    column <- copy left
+    move-cursor screen, row, column
     # initial leader for each row: two spaces and a '.'
-    print-character screen:address, 32/space, 245/grey
-    print-character screen:address, 32/space, 245/grey
-    print-character screen:address, 46/full-stop, 245/grey
-    column:number <- add left:number, 3
+    print-character screen, 32/space, 245/grey
+    print-character screen, 32/space, 245/grey
+    print-character screen, 46/full-stop, 245/grey
+    column <- add left, 3
     {
       # print row
-      row-done?:boolean <- greater-or-equal column:number, max-column:number
-      break-if row-done?:boolean
-      curr:screen-cell <- index buf:address:array:screen-cell/lookup, i:number
-      c:character <- get curr:screen-cell, contents:offset
-      print-character screen:address, c:character, 245/grey
-      column:number <- add column:number, 1
-      i:number <- add i:number, 1
+      row-done?:boolean <- greater-or-equal column, max-column
+      break-if row-done?
+      curr:screen-cell <- index *buf, i
+      c:character <- get curr, contents:offset
+      print-character screen, c, 245/grey
+      column <- add column, 1
+      i <- add i, 1
       loop
     }
     # print final '.'
-    print-character screen:address, 46/full-stop, 245/grey
-    column:number <- add column:number, 1
+    print-character screen, 46/full-stop, 245/grey
+    column <- add column, 1
     {
       # clear rest of current line
-      line-done?:boolean <- greater-than column:number, right:number
-      break-if line-done?:boolean
-      print-character screen:address, 32/space
-      column:number <- add column:number, 1
+      line-done?:boolean <- greater-than column, right
+      break-if line-done?
+      print-character screen, 32/space
+      column <- add column, 1
       loop
     }
-    row:number <- add row:number, 1
+    row <- add row, 1
     loop
   }
-  reply row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
+  reply row/same-as-ingredient:4, screen/same-as-ingredient:0
 ]
 
 recipe clear-line-delimited [
@@ -409,12 +409,12 @@ recipe clear-line-delimited [
   screen:address <- next-ingredient
   left:number <- next-ingredient
   right:number <- next-ingredient
-  column:number <- copy left:number
+  column:number <- copy left
   {
-    done?:boolean <- greater-than column:number, right:number
-    break-if done?:boolean
-    print-character screen:address, 32/space
-    column:number <- add column:number, 1
+    done?:boolean <- greater-than column, right
+    break-if done?
+    print-character screen, 32/space
+    column <- add column, 1
     loop
   }
 ]
@@ -509,8 +509,8 @@ scenario editor-initializes-empty-text [
   run [
     1:address:array:character <- new []
     2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .     .
@@ -562,47 +562,47 @@ recipe get-color [
   color:number <- next-ingredient
   highlighting-state:number <- next-ingredient
   c:character <- next-ingredient
-  color-is-white?:boolean <- equal color:number, 7/white
-#?   $print [character: ], c:character, 10/newline #? 1
+  color-is-white?:boolean <- equal color, 7/white
+#?   $print [character: ], c, 10/newline #? 1
   # if color is white and next character is '#', switch color to blue
   {
-    break-unless color-is-white?:boolean
-    starting-comment?:boolean <- equal c:character, 35/#
-    break-unless starting-comment?:boolean
+    break-unless color-is-white?
+    starting-comment?:boolean <- equal c, 35/#
+    break-unless starting-comment?
 #?     $print [switch color back to blue], 10/newline #? 1
-    color:number <- copy 12/lightblue
+    color <- copy 12/lightblue
     jump +exit:label
   }
   # if color is blue and next character is newline, switch color to white
   {
-    color-is-blue?:boolean <- equal color:number, 12/lightblue
-    break-unless color-is-blue?:boolean
-    ending-comment?:boolean <- equal c:character, 10/newline
-    break-unless ending-comment?:boolean
+    color-is-blue?:boolean <- equal color, 12/lightblue
+    break-unless color-is-blue?
+    ending-comment?:boolean <- equal c, 10/newline
+    break-unless ending-comment?
 #?     $print [switch color back to white], 10/newline #? 1
-    color:number <- copy 7/white
+    color <- copy 7/white
     jump +exit:label
   }
   # if color is white (no comments) and next character is '<', switch color to red
   {
-    break-unless color-is-white?:boolean
-    starting-assignment?:boolean <- equal c:character, 60/<
-    break-unless starting-assignment?:boolean
-    color:number <- copy 1/red
+    break-unless color-is-white?
+    starting-assignment?:boolean <- 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:number, 1/red
-    break-unless color-is-red?:boolean
-    ending-assignment?:boolean <- equal c:character, 32/space
-    break-unless ending-assignment?:boolean
-    color:number <- copy 7/white
+    color-is-red?:boolean <- equal color, 1/red
+    break-unless color-is-red?
+    ending-assignment?:boolean <- equal c, 32/space
+    break-unless ending-assignment?
+    color <- copy 7/white
     jump +exit:label
   }
   # otherwise no change
   +exit
-  reply color:number, highlighting-state:number
+  reply color, highlighting-state
 ]
 
 scenario render-colors-assignment [
@@ -636,78 +636,78 @@ recipe event-loop [
   screen:address <- next-ingredient
   console:address <- next-ingredient
   env:address:programming-environment-data <- next-ingredient
-  recipes:address:editor-data <- get env:address:programming-environment-data/lookup, recipes:offset
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
-  sandbox-in-focus?:address:boolean <- get-address env:address:programming-environment-data/lookup, sandbox-in-focus?:offset
+  recipes:address:editor-data <- get *env, recipes:offset
+  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  sandbox-in-focus?:address:boolean <- get-address *env, sandbox-in-focus?:offset
   {
     # looping over each (keyboard or touch) event as it occurs
     +next-event
-    e:event, console:address, found?:boolean, quit?:boolean <- read-event console:address
-    loop-unless found?:boolean
-    break-if quit?:boolean  # only in tests
+    e:event, console, found?:boolean, quit?:boolean <- read-event console
+    loop-unless found?
+    break-if quit?  # only in tests
     trace [app], [next-event]
     # check for global events that will trigger regardless of which editor has focus
     {
       k:address:number <- maybe-convert e:event, keycode:variant
-      break-unless k:address:number
+      break-unless k
       # F4? load all code and run all sandboxes.
       {
-        do-run?:boolean <- equal k:address:number/lookup, 65532/F4
-        break-unless do-run?:boolean
-        run-sandboxes env:address:programming-environment-data
+        do-run?:boolean <- equal *k, 65532/F4
+        break-unless do-run?
+        run-sandboxes env
         # F4 might update warnings and results on both sides
-        screen:address <- render-all screen:address, env:address:programming-environment-data
-        update-cursor screen:address, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:address:boolean/lookup
-        show-screen screen:address
+        screen <- render-all screen, env
+        update-cursor screen, recipes, current-sandbox, *sandbox-in-focus?
+        show-screen screen
         loop +next-event:label
       }
     }
     {
       c:address:character <- maybe-convert e:event, text:variant
-      break-unless c:address:character
+      break-unless c
       # ctrl-n? - switch focus
       {
-        ctrl-n?:boolean <- equal c:address:character/lookup, 14/ctrl-n
-        break-unless ctrl-n?:boolean
-        sandbox-in-focus?:address:boolean/lookup <- not sandbox-in-focus?:address:boolean/lookup
-        update-cursor screen:address, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:address:boolean/lookup
-        show-screen screen:address
+        ctrl-n?:boolean <- equal *c, 14/ctrl-n
+        break-unless ctrl-n?
+        *sandbox-in-focus? <- not *sandbox-in-focus?
+        update-cursor screen, recipes, current-sandbox, *sandbox-in-focus?
+        show-screen screen
         loop +next-event:label
       }
     }
     # 'touch' event
     {
       t:address:touch-event <- maybe-convert e:event, touch:variant
-      break-unless t:address:touch-event
+      break-unless t
       # ignore all but 'left-click' events for now
       # todo: test this
-      touch-type:number <- get t:address:touch-event/lookup, type:offset
-      is-left-click?:boolean <- equal touch-type:number, 65513/mouse-left
-      loop-unless is-left-click?:boolean, +next-event:label
+      touch-type:number <- get *t, type:offset
+      is-left-click?:boolean <- equal touch-type, 65513/mouse-left
+      loop-unless is-left-click?, +next-event:label
       # on a sandbox delete icon? process delete
       {
-        was-delete?:boolean <- delete-sandbox t:address:touch-event/lookup, env:address:programming-environment-data
-        break-unless was-delete?:boolean
+        was-delete?:boolean <- delete-sandbox *t, env
+        break-unless was-delete?
 #?         trace [app], [delete clicked] #? 1
-        screen:address <- render-sandbox-side screen:address, env:address:programming-environment-data, 1/clear
-        update-cursor screen:address, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:address:boolean/lookup
-        show-screen screen:address
+        screen <- render-sandbox-side screen, env, 1/clear
+        update-cursor screen, recipes, current-sandbox, *sandbox-in-focus?
+        show-screen screen
         loop +next-event:label
       }
       # if not, send to both editors
-      _ <- move-cursor-in-editor screen:address, recipes:address:editor-data, t:address:touch-event/lookup
-      sandbox-in-focus?:address:boolean/lookup <- move-cursor-in-editor screen:address, current-sandbox:address:editor-data, t:address:touch-event/lookup
+      _ <- move-cursor-in-editor screen, recipes, *t
+      *sandbox-in-focus? <- move-cursor-in-editor screen, current-sandbox, *t
       jump +continue:label
     }
     # if it's not global, send to appropriate editor
     {
       {
-        break-if sandbox-in-focus?:address:boolean/lookup
-        handle-event screen:address, console:address, recipes:address:editor-data, e:event
+        break-if *sandbox-in-focus?
+        handle-event screen, console, recipes, e:event
       }
       {
-        break-unless sandbox-in-focus?:address:boolean/lookup
-        handle-event screen:address, console:address, current-sandbox:address:editor-data, e:event
+        break-unless *sandbox-in-focus?
+        handle-event screen, console, current-sandbox, e:event
       }
     }
     +continue
@@ -716,9 +716,9 @@ recipe event-loop [
     # they won't usually come fast enough to trigger this.
     # todo: test this
     {
-      more-events?:boolean <- has-more-events? console:address
-      break-if more-events?:boolean
-      render-minimal screen:address, env:address:programming-environment-data
+      more-events?:boolean <- has-more-events? console
+      break-if more-events?
+      render-minimal screen, env
     }
     loop
   }
@@ -733,27 +733,27 @@ recipe editor-event-loop [
   {
     # looping over each (keyboard or touch) event as it occurs
     +next-event
-    e:event, console:address, found?:boolean, quit?:boolean <- read-event console:address
-    loop-unless found?:boolean
-    break-if quit?:boolean  # only in tests
+    e:event, console:address, found?:boolean, quit?:boolean <- read-event console
+    loop-unless found?
+    break-if quit?  # only in tests
     trace [app], [next-event]
     # 'touch' event - send to both editors
     {
       t:address:touch-event <- maybe-convert e:event, touch:variant
-      break-unless t:address:touch-event
-      move-cursor-in-editor screen:address, editor:address:editor-data, t:address:touch-event/lookup
+      break-unless t
+      move-cursor-in-editor screen, editor, *t
       jump +continue:label
     }
     # other events - send to appropriate editor
-    handle-event screen:address, console:address, editor:address:editor-data, e:event
+    handle-event screen, console, editor, e:event
     +continue
-    row:number, screen:address <- render screen:address, editor:address:editor-data
+    row:number, screen <- render screen, editor
     # clear next line, in case we just processed a backspace
-    left:number <- get editor:address:editor-data/lookup, left:offset
-    right:number <- get editor:address:editor-data/lookup, right:offset
-    row:number <- add row:number, 1
-    move-cursor screen:address, row:number, left:number
-    clear-line-delimited screen:address, left:number, right:number
+    left:number <- get *editor, left:offset
+    right:number <- get *editor, right:offset
+    row <- add row, 1
+    move-cursor screen, row, left
+    clear-line-delimited screen, left, right
     loop
   }
 ]
@@ -764,185 +764,185 @@ recipe handle-event [
   console:address <- next-ingredient
   editor:address:editor-data <- next-ingredient
   e:event <- next-ingredient
-  reply-unless editor:address:editor-data
+  reply-unless editor
   # character
   {
     c:address:character <- maybe-convert e:event, text:variant
-    break-unless c:address:character
+    break-unless c
     ## check for special characters
     # backspace - delete character before cursor
     {
-      backspace?:boolean <- equal c:address:character/lookup, 8/backspace
-      break-unless backspace?:boolean
-      delete-before-cursor editor:address:editor-data
+      backspace?:boolean <- equal *c, 8/backspace
+      break-unless backspace?
+      delete-before-cursor editor
       reply
     }
     # ctrl-a - move cursor to start of line
     {
-      ctrl-a?:boolean <- equal c:address:character/lookup, 1/ctrl-a
-      break-unless ctrl-a?:boolean
-      move-to-start-of-line editor:address:editor-data
+      ctrl-a?:boolean <- equal *c, 1/ctrl-a
+      break-unless ctrl-a?
+      move-to-start-of-line editor
       reply
     }
     # ctrl-e - move cursor to end of line
     {
-      ctrl-e?:boolean <- equal c:address:character/lookup, 5/ctrl-e
-      break-unless ctrl-e?:boolean
-      move-to-end-of-line editor:address:editor-data
+      ctrl-e?:boolean <- equal *c, 5/ctrl-e
+      break-unless ctrl-e?
+      move-to-end-of-line editor
       reply
     }
     # ctrl-u - delete until start of line (excluding cursor)
     {
-      ctrl-u?:boolean <- equal c:address:character/lookup, 21/ctrl-u
-      break-unless ctrl-u?:boolean
-      delete-to-start-of-line editor:address:editor-data
+      ctrl-u?:boolean <- equal *c, 21/ctrl-u
+      break-unless ctrl-u?
+      delete-to-start-of-line editor
       reply
     }
     # ctrl-k - delete until end of line (including cursor)
     {
-      ctrl-k?:boolean <- equal c:address:character/lookup, 11/ctrl-k
-      break-unless ctrl-k?:boolean
-      delete-to-end-of-line editor:address:editor-data
+      ctrl-k?:boolean <- equal *c, 11/ctrl-k
+      break-unless ctrl-k?
+      delete-to-end-of-line editor
       reply
     }
     # tab - insert two spaces
     {
-      tab?:boolean <- equal c:address:character/lookup, 9/tab
+      tab?:boolean <- equal *c, 9/tab
       break-unless tab?:boolean
-      insert-at-cursor editor:address:editor-data, 32/space, screen:address
-      insert-at-cursor editor:address:editor-data, 32/space, screen:address
+      insert-at-cursor editor, 32/space, screen
+      insert-at-cursor editor, 32/space, screen
       reply
     }
     # otherwise type it in
-    insert-at-cursor editor:address:editor-data, c:address:character/lookup, screen:address
+    insert-at-cursor editor, *c, screen
     reply
   }
   # otherwise it's a special key
   k:address:number <- maybe-convert e:event, keycode:variant
-  assert k:address:number, [event was of unknown type; neither keyboard nor mouse]
-  d:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  cursor-row:address:number <- get-address editor:address:editor-data/lookup, cursor-row:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  screen-height:number <- screen-height screen:address
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  right:number <- get editor:address:editor-data/lookup, right:offset
+  assert k, [event was of unknown type; neither keyboard nor mouse]
+  d:address:duplex-list <- get *editor, data:offset
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  cursor-row:address:number <- get-address *editor, cursor-row:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  screen-height:number <- screen-height screen
+  left:number <- get *editor, left:offset
+  right:number <- get *editor, right:offset
   # arrows; update cursor-row and cursor-column, leave before-cursor to 'render'.
   # right arrow
   {
-    move-to-next-character?:boolean <- equal k:address:number/lookup, 65514/right-arrow
-    break-unless move-to-next-character?:boolean
+    move-to-next-character?:boolean <- equal *k, 65514/right-arrow
+    break-unless move-to-next-character?
     # if not at end of text
-    old-cursor:address:duplex-list <- next-duplex before-cursor:address:address:duplex-list/lookup
-    break-unless old-cursor:address:duplex-list
+    old-cursor:address:duplex-list <- next-duplex *before-cursor
+    break-unless old-cursor
     # scan to next character
-    before-cursor:address:address:duplex-list/lookup <- copy old-cursor:address:duplex-list
+    *before-cursor <- copy old-cursor
     # if crossed a newline, move cursor to start of next row
     {
-      old-cursor-character:character <- get before-cursor:address:address:duplex-list/lookup/lookup, value:offset
-      was-at-newline?:boolean <- equal old-cursor-character:character, 10/newline
-      break-unless was-at-newline?:boolean
-      cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
-      cursor-column:address:number/lookup <- copy left:number
+      old-cursor-character:character <- get **before-cursor, value:offset
+      was-at-newline?:boolean <- equal old-cursor-character, 10/newline
+      break-unless was-at-newline?
+      *cursor-row <- add *cursor-row, 1
+      *cursor-column <- copy left
       # todo: what happens when cursor is too far down?
-      screen-height:number <- screen-height screen:address
-      above-screen-bottom?:boolean <- lesser-than cursor-row:address:number/lookup, screen-height:number
-      assert above-screen-bottom?:boolean, [unimplemented: moving past bottom of screen]
+      screen-height <- screen-height screen
+      above-screen-bottom?:boolean <- lesser-than *cursor-row, screen-height
+      assert above-screen-bottom?, [unimplemented: moving past bottom of screen]
       reply
     }
     # 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:number, 1
-      at-wrap?:boolean <- equal cursor-column:address:number/lookup, wrap-column:number
-      break-unless at-wrap?:boolean
+      wrap-column:number <- subtract right, 1
+      at-wrap?:boolean <- equal *cursor-column, wrap-column
+      break-unless at-wrap?
       # and if next character isn't newline
-      new-cursor:address:duplex-list <- next-duplex old-cursor:address:duplex-list
-      break-unless new-cursor:address:duplex-list
-      next-character:character <- get new-cursor:address:duplex-list/lookup, value:offset
-      newline?:boolean <- equal next-character:character, 10/newline
-      break-if newline?:boolean
-      cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
-      cursor-column:address:number/lookup <- copy left:number
+      new-cursor:address:duplex-list <- next-duplex old-cursor
+      break-unless new-cursor
+      next-character:character <- get *new-cursor, value:offset
+      newline?:boolean <- equal next-character, 10/newline
+      break-if newline?
+      *cursor-row <- add *cursor-row, 1
+      *cursor-column <- copy left
       # todo: what happens when cursor is too far down?
-      above-screen-bottom?:boolean <- lesser-than cursor-row:address:number/lookup, screen-height:number
-      assert above-screen-bottom?:boolean, [unimplemented: moving past bottom of screen]
+      above-screen-bottom?:boolean <- lesser-than *cursor-row, screen-height
+      assert above-screen-bottom?, [unimplemented: moving past bottom of screen]
       reply
     }
     # otherwise move cursor one character right
-    cursor-column:address:number/lookup <- add cursor-column:address:number/lookup, 1
+    *cursor-column <- add *cursor-column, 1
   }
   # left arrow
   {
-    move-to-previous-character?:boolean <- equal k:address:number/lookup, 65515/left-arrow
-    break-unless move-to-previous-character?:boolean
+    move-to-previous-character?:boolean <- equal *k, 65515/left-arrow
+    break-unless move-to-previous-character?
 #?     trace [app], [left arrow] #? 1
     # if not at start of text (before-cursor at § sentinel)
-    prev:address:duplex-list <- prev-duplex before-cursor:address:address:duplex-list/lookup
-    break-unless prev:address:duplex-list
+    prev:address:duplex-list <- prev-duplex *before-cursor
+    break-unless prev
     # if cursor not at left margin, move one character left
     {
-      at-left-margin?:boolean <- equal cursor-column:address:number/lookup, 0
-      break-if at-left-margin?:boolean
+      at-left-margin?:boolean <- equal *cursor-column, 0
+      break-if at-left-margin?
 #?       trace [app], [decrementing] #? 1
-      cursor-column:address:number/lookup <- subtract cursor-column:address:number/lookup, 1
+      *cursor-column <- subtract *cursor-column, 1
       reply
     }
     # if at left margin, there's guaranteed to be a previous line, since we're
     # not at start of text
     {
       # if before-cursor is at newline, figure out how long the previous line is
-      prevc:character <- get before-cursor:address:address:duplex-list/lookup/lookup, value:offset
-      previous-character-is-newline?:boolean <- equal prevc:character, 10/newline
-      break-unless previous-character-is-newline?:boolean
+      prevc:character <- get **before-cursor, value:offset
+      previous-character-is-newline?:boolean <- equal prevc, 10/newline
+      break-unless previous-character-is-newline?
 #?       trace [app], [previous line] #? 1
       # compute length of previous line
-      end-of-line:number <- previous-line-length before-cursor:address:address:duplex-list/lookup, d:address:duplex-list
-      cursor-row:address:number/lookup <- subtract cursor-row:address:number/lookup, 1
-      cursor-column:address:number/lookup <- copy end-of-line:number
+      end-of-line:number <- previous-line-length *before-cursor, d
+      *cursor-row <- subtract *cursor-row, 1
+      *cursor-column <- copy end-of-line
       reply
     }
     # if before-cursor is not at newline, we're just at a wrapped line
-    assert cursor-row:address:number/lookup, [unimplemented: moving cursor above top of screen]
-    cursor-row:address:number/lookup <- subtract cursor-row:address:number/lookup, 1
-    cursor-column:address:number/lookup <- subtract right:number, 1  # leave room for wrap icon
+    assert *cursor-row, [unimplemented: moving cursor above top of screen]
+    *cursor-row <- subtract *cursor-row, 1
+    *cursor-column <- subtract right, 1  # leave room for wrap icon
   }
   # down arrow
   {
-    move-to-next-line?:boolean <- equal k:address:number/lookup, 65516/down-arrow
-    break-unless move-to-next-line?:boolean
+    move-to-next-line?:boolean <- equal *k, 65516/down-arrow
+    break-unless move-to-next-line?
     # todo: support scrolling
-    already-at-bottom?:boolean <- greater-or-equal cursor-row:address:number/lookup, screen-height:number
-    break-if already-at-bottom?:boolean
+    already-at-bottom?:boolean <- greater-or-equal *cursor-row, screen-height
+    break-if already-at-bottom?
 #?     $print [moving down
 #? ] #? 1
-    cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
+    *cursor-row <- add *cursor-row, 1
     # that's it; render will adjust cursor-column as necessary
   }
   # up arrow
   {
-    move-to-previous-line?:boolean <- equal k:address:number/lookup, 65517/up-arrow
-    break-unless move-to-previous-line?:boolean
+    move-to-previous-line?:boolean <- equal *k, 65517/up-arrow
+    break-unless move-to-previous-line?
     # todo: support scrolling
-    already-at-top?:boolean <- lesser-or-equal cursor-row:address:number/lookup, 1/top
-    break-if already-at-top?:boolean
+    already-at-top?:boolean <- lesser-or-equal *cursor-row, 1/top
+    break-if already-at-top?
 #?     $print [moving up
 #? ] #? 1
-    cursor-row:address:number/lookup <- subtract cursor-row:address:number/lookup, 1
+    *cursor-row <- subtract *cursor-row, 1
     # that's it; render will adjust cursor-column as necessary
   }
   # home
   {
-    home?:boolean <- equal k:address:number/lookup, 65521/home
-    break-unless home?:boolean
-    move-to-start-of-line editor:address:editor-data
+    home?:boolean <- equal *k, 65521/home
+    break-unless home?
+    move-to-start-of-line editor
     reply
   }
   # end
   {
-    end?:boolean <- equal k:address:number/lookup, 65520/end
-    break-unless end?:boolean
-    move-to-end-of-line editor:address:editor-data
+    end?:boolean <- equal *k, 65520/end
+    break-unless end?
+    move-to-end-of-line editor
     reply
   }
 ]
@@ -954,19 +954,19 @@ recipe move-cursor-in-editor [
   screen:address <- next-ingredient
   editor:address:editor-data <- next-ingredient
   t:touch-event <- next-ingredient
-  reply-unless editor:address:editor-data, 0/false
-  click-column:number <- get t:touch-event, column:offset
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  too-far-left?:boolean <- lesser-than click-column:number, left:number
-  reply-if too-far-left?:boolean, 0/false
-  right:number <- get editor:address:editor-data/lookup, right:offset
-  too-far-right?:boolean <- greater-than click-column:number, right:number
-  reply-if too-far-right?:boolean, 0/false
+  reply-unless editor, 0/false
+  click-column:number <- get t, column:offset
+  left:number <- get *editor, left:offset
+  too-far-left?:boolean <- lesser-than click-column, left
+  reply-if too-far-left?, 0/false
+  right:number <- get *editor, right:offset
+  too-far-right?:boolean <- greater-than click-column, right
+  reply-if too-far-right?, 0/false
   # update cursor
-  cursor-row:address:number <- get-address editor:address:editor-data/lookup, cursor-row:offset
-  cursor-row:address:number/lookup <- get t:touch-event, row:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  cursor-column:address:number/lookup <- get t:touch-event, column:offset
+  cursor-row:address:number <- get-address *editor, cursor-row:offset
+  *cursor-row <- get t, row:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  *cursor-column <- get t, column:offset
   # gain focus
   reply 1/true
 ]
@@ -976,33 +976,33 @@ recipe insert-at-cursor [
   editor:address:editor-data <- next-ingredient
   c:character <- next-ingredient
   screen:address <- next-ingredient
-#?   $print [insert ], c:character, 10/newline #? 1
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  insert-duplex c:character, before-cursor:address:address:duplex-list/lookup
-  before-cursor:address:address:duplex-list/lookup <- next-duplex before-cursor:address:address:duplex-list/lookup
-  cursor-row:address:number <- get-address editor:address:editor-data/lookup, cursor-row:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  right:number <- get editor:address:editor-data/lookup, right:offset
+#?   $print [insert ], c, 10/newline #? 1
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  insert-duplex c, *before-cursor
+  *before-cursor <- next-duplex *before-cursor
+  cursor-row:address:number <- get-address *editor, cursor-row:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  left:number <- get *editor, left:offset
+  right:number <- get *editor, right:offset
   # update cursor: if newline, move cursor to start of next line
   # todo: bottom of screen
   {
-    newline?:boolean <- equal c:character, 10/newline
-    break-unless newline?:boolean
-    cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
-    cursor-column:address:number/lookup <- copy left:number
+    newline?:boolean <- equal c, 10/newline
+    break-unless newline?
+    *cursor-row <- add *cursor-row, 1
+    *cursor-column <- copy left
     # indent if necessary
 #?     $print [computing indent], 10/newline #? 1
-    d:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
-    end-of-previous-line:address:duplex-list <- prev-duplex before-cursor:address:address:duplex-list/lookup
-    indent:number <- line-indent end-of-previous-line:address:duplex-list, d:address:duplex-list
-#?     $print indent:number, 10/newline #? 1
+    d:address:duplex-list <- get *editor, data:offset
+    end-of-previous-line:address:duplex-list <- prev-duplex *before-cursor
+    indent:number <- line-indent end-of-previous-line, d
+#?     $print indent, 10/newline #? 1
     i:number <- copy 0
     {
-      indent-done?:boolean <- greater-or-equal i:number, indent:number
-      break-if indent-done?:boolean
-      insert-at-cursor editor:address:editor-data, 32/space, screen:address
-      i:number <- add i:number, 1
+      indent-done?:boolean <- greater-or-equal i, indent
+      break-if indent-done?
+      insert-at-cursor editor, 32/space, screen
+      i <- add i, 1
       loop
     }
     reply
@@ -1010,42 +1010,42 @@ recipe insert-at-cursor [
   # if the line wraps at the cursor, move cursor to start of next row
   {
     # if we're at the column just before the wrap indicator
-    wrap-column:number <- subtract right:number, 1
-#?     $print [wrap? ], cursor-column:address:number/lookup, [ vs ], wrap-column:number, 10/newline
-    at-wrap?:boolean <- greater-or-equal cursor-column:address:number/lookup, wrap-column:number
-    break-unless at-wrap?:boolean
+    wrap-column:number <- subtract right, 1
+#?     $print [wrap? ], *cursor-column, [ vs ], wrap-column, 10/newline
+    at-wrap?:boolean <- greater-or-equal *cursor-column, wrap-column
+    break-unless at-wrap?
 #?     $print [wrap!
 #? ] #? 1
-    cursor-column:address:number/lookup <- subtract cursor-column:address:number/lookup, wrap-column:number
-    cursor-row:address:number/lookup <- add cursor-row:address:number/lookup, 1
+    *cursor-column <- subtract *cursor-column, wrap-column
+    *cursor-row <- add *cursor-row, 1
     # todo: what happens when cursor is too far down?
-    screen-height:number <- screen-height screen:address
-    above-screen-bottom?:boolean <- lesser-than cursor-row:address:number/lookup, screen-height:number
-    assert above-screen-bottom?:boolean, [unimplemented: typing past bottom of screen]
+    screen-height:number <- screen-height screen
+    above-screen-bottom?:boolean <- lesser-than *cursor-row, screen-height
+    assert above-screen-bottom?, [unimplemented: typing past bottom of screen]
 #?     $print [return
 #? ] #? 1
     reply
   }
   # otherwise move cursor right
-  cursor-column:address:number/lookup <- add cursor-column:address:number/lookup, 1
+  *cursor-column <- add *cursor-column, 1
 ]
 
 recipe delete-before-cursor [
   local-scope
   editor:address:editor-data <- next-ingredient
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  d:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
+  before-cursor:address:address:duplex-list <- get-address *editor:address:editor-data, before-cursor:offset
+  d:address:duplex-list <- get *editor:address:editor-data, data:offset
   # unless already at start
-  at-start?:boolean <- equal before-cursor:address:address:duplex-list/lookup, d:address:duplex-list
+  at-start?:boolean <- equal *before-cursor:address:address:duplex-list, d:address:duplex-list
   reply-if at-start?:boolean
   # delete character
-  prev:address:duplex-list <- prev-duplex before-cursor:address:address:duplex-list/lookup
-  remove-duplex before-cursor:address:address:duplex-list/lookup
+  prev:address:duplex-list <- prev-duplex *before-cursor:address:address:duplex-list
+  remove-duplex *before-cursor:address:address:duplex-list
   # update cursor
-  before-cursor:address:address:duplex-list/lookup <- copy prev:address:duplex-list
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  cursor-column:address:number/lookup <- subtract cursor-column:address:number/lookup, 1
-#?   $print [delete-before-cursor: ], cursor-column:address:number/lookup, 10/newline
+  *before-cursor:address:address:duplex-list <- copy prev:address:duplex-list
+  cursor-column:address:number <- get-address *editor:address:editor-data, cursor-column:offset
+  *cursor-column:address:number <- subtract *cursor-column:address:number, 1
+#?   $print [delete-before-cursor: ], *cursor-column:address:number, 10/newline
 ]
 
 # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
@@ -1055,21 +1055,21 @@ recipe previous-line-length [
   curr:address:duplex-list <- next-ingredient
   start:address:duplex-list <- next-ingredient
   result:number <- copy 0
-  reply-unless curr:address:duplex-list, result:number
-  at-start?:boolean <- equal curr:address:duplex-list, start:address:duplex-list
-  reply-if at-start?:boolean, result:number
+  reply-unless curr, result
+  at-start?:boolean <- equal curr, start
+  reply-if at-start?, result
   {
-    curr:address:duplex-list <- prev-duplex curr:address:duplex-list
-    break-unless curr:address:duplex-list
-    at-start?:boolean <- equal curr:address:duplex-list, start:address:duplex-list
-    break-if at-start?:boolean
-    c:character <- get curr:address:duplex-list/lookup, value:offset
-    at-newline?:boolean <- equal c:character 10/newline
-    break-if at-newline?:boolean
-    result:number <- add result:number, 1
+    curr <- prev-duplex curr
+    break-unless curr
+    at-start?:boolean <- equal curr, start
+    break-if at-start?
+    c:character <- get *curr, value:offset
+    at-newline?:boolean <- equal c, 10/newline
+    break-if at-newline?
+    result <- add result, 1
     loop
   }
-  reply result:number
+  reply result
 ]
 
 # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts
@@ -1079,57 +1079,57 @@ recipe line-indent [
   curr:address:duplex-list <- next-ingredient
   start:address:duplex-list <- next-ingredient
   result:number <- copy 0
-  reply-unless curr:address:duplex-list, result:number
+  reply-unless curr, result
 #?   $print [a0], 10/newline #? 1
-  at-start?:boolean <- equal curr:address:duplex-list, start:address:duplex-list
-  reply-if at-start?:boolean, result:number
+  at-start?:boolean <- equal curr, start
+  reply-if at-start?, result
 #?   $print [a1], 10/newline #? 1
   {
-    curr:address:duplex-list <- prev-duplex curr:address:duplex-list
-    break-unless curr:address:duplex-list
+    curr <- prev-duplex curr
+    break-unless curr
 #?   $print [a2], 10/newline #? 1
-    at-start?:boolean <- equal curr:address:duplex-list, start:address:duplex-list
-    break-if at-start?:boolean
+    at-start?:boolean <- equal curr, start
+    break-if at-start?
 #?   $print [a3], 10/newline #? 1
-    c:character <- get curr:address:duplex-list/lookup, value:offset
-    at-newline?:boolean <- equal c:character, 10/newline
-    break-if at-newline?:boolean
+    c:character <- get *curr, value:offset
+    at-newline?:boolean <- equal c, 10/newline
+    break-if at-newline?
 #?   $print [a4], 10/newline #? 1
     # if c is a space, increment result
-    is-space?:boolean <- equal c:character, 32/space
+    is-space?:boolean <- equal c, 32/space
     {
-      break-unless is-space?:boolean
-      result:number <- add result:number, 1
+      break-unless is-space?
+      result <- add result, 1
     }
     # if c is not a space, reset result
     {
-      break-if is-space?:boolean
-      result:number <- copy 0
+      break-if is-space?
+      result <- copy 0
     }
     loop
   }
-  reply result:number
+  reply result
 ]
 
 recipe move-to-start-of-line [
   local-scope
   editor:address:editor-data <- next-ingredient
   # update cursor column
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  cursor-column:address:number/lookup <- copy left:number
+  left:number <- get *editor, left:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  *cursor-column <- copy left
   # update before-cursor
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  init:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  init:address:duplex-list <- get *editor, data:offset
   # while not at start of line, move 
   {
-    at-start-of-text?:boolean <- equal before-cursor:address:address:duplex-list/lookup, init:address:duplex-list
-    break-if at-start-of-text?:boolean
-    prev:character <- get before-cursor:address:address:duplex-list/lookup/lookup, value:offset
-    at-start-of-line?:boolean <- equal prev:character, 10/newline
-    break-if at-start-of-line?:boolean
-    before-cursor:address:address:duplex-list/lookup <- prev-duplex before-cursor:address:address:duplex-list/lookup
-    assert before-cursor:address:address:duplex-list/lookup, [move-to-start-of-line tried to move before start of text]
+    at-start-of-text?:boolean <- 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
+    break-if at-start-of-line?
+    *before-cursor <- prev-duplex *before-cursor
+    assert *before-cursor, [move-to-start-of-line tried to move before start of text]
     loop
   }
 ]
@@ -1137,75 +1137,75 @@ recipe move-to-start-of-line [
 recipe move-to-end-of-line [
   local-scope
   editor:address:editor-data <- next-ingredient
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
   # while not at start of line, move 
   {
-    next:address:duplex-list <- next-duplex before-cursor:address:address:duplex-list/lookup
-    break-unless next:address:duplex-list  # end of text
-    nextc:character <- get next:address:duplex-list/lookup, value:offset
-    at-end-of-line?:boolean <- equal nextc:character, 10/newline
-    break-if at-end-of-line?:boolean
-    before-cursor:address:address:duplex-list/lookup <- copy next:address:duplex-list
-    cursor-column:address:number/lookup <- add cursor-column:address:number/lookup, 1
+    next:address:duplex-list <- next-duplex *before-cursor
+    break-unless next  # end of text
+    nextc:character <- get *next, value:offset
+    at-end-of-line?:boolean <- equal nextc, 10/newline
+    break-if at-end-of-line?
+    *before-cursor <- copy next
+    *cursor-column <- add *cursor-column, 1
     loop
   }
-  # move one past end of line
-  cursor-column:address:number/lookup <- add cursor-column:address:number/lookup, 1
+  # move one past final character
+  *cursor-column <- add *cursor-column, 1
 ]
 
 recipe delete-to-start-of-line [
   local-scope
   editor:address:editor-data <- next-ingredient
   # compute range to delete
-  init:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
-  before-cursor:address:address:duplex-list <- get-address editor:address:editor-data/lookup, before-cursor:offset
-  start:address:duplex-list <- copy before-cursor:address:address:duplex-list/lookup
-  end:address:duplex-list <- next-duplex before-cursor:address:address:duplex-list/lookup
+  init:address:duplex-list <- get *editor, data:offset
+  before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset
+  start:address:duplex-list <- copy *before-cursor
+  end:address:duplex-list <- next-duplex *before-cursor
   {
-    at-start-of-text?:boolean <- equal start:address:duplex-list, init:address:duplex-list
-    break-if at-start-of-text?:boolean
-    curr:character <- get start:address:duplex-list/lookup, value:offset
-    at-start-of-line?:boolean <- equal curr:character, 10/newline
-    break-if at-start-of-line?:boolean
-    start:address:duplex-list <- prev-duplex start:address:duplex-list
-    assert start:address:duplex-list, [delete-to-start-of-line tried to move before start of text]
+    at-start-of-text?:boolean <- equal start, init
+    break-if at-start-of-text?
+    curr:character <- get *start, value:offset
+    at-start-of-line?:boolean <- equal curr, 10/newline
+    break-if at-start-of-line?
+    start <- prev-duplex start
+    assert start, [delete-to-start-of-line tried to move before start of text]
     loop
   }
   # snip it out
-  start-next:address:address:duplex-list <- get-address start:address:duplex-list/lookup, next:offset
-  start-next:address:address:duplex-list/lookup <- copy end:address:duplex-list
-  end-prev:address:address:duplex-list <- get-address end:address:duplex-list/lookup, prev:offset
-  end-prev:address:address:duplex-list/lookup <- copy start:address:duplex-list
+  start-next:address:address:duplex-list <- get-address *start, next:offset
+  *start-next <- copy end
+  end-prev:address:address:duplex-list <- get-address *end, prev:offset
+  *end-prev <- copy start
   # adjust cursor
-  before-cursor:address:address:duplex-list/lookup <- prev-duplex end:address:duplex-list
-  left:number <- get editor:address:editor-data/lookup, left:offset
-  cursor-column:address:number <- get-address editor:address:editor-data/lookup, cursor-column:offset
-  cursor-column:address:number/lookup <- copy left:number
+  *before-cursor <- prev-duplex end
+  left:number <- get *editor, left:offset
+  cursor-column:address:number <- get-address *editor, cursor-column:offset
+  *cursor-column <- copy left
 ]
 
 recipe delete-to-end-of-line [
   local-scope
   editor:address:editor-data <- next-ingredient
   # compute range to delete
-  start:address:duplex-list <- get editor:address:editor-data/lookup, before-cursor:offset
-  end:address:duplex-list <- next-duplex start:address:duplex-list
+  start:address:duplex-list <- get *editor, before-cursor:offset
+  end:address:duplex-list <- next-duplex start
   {
-    at-end-of-text?:boolean <- equal end:address:duplex-list, 0/null
-    break-if at-end-of-text?:boolean
-    curr:character <- get end:address:duplex-list/lookup, value:offset
-    at-end-of-line?:boolean <- equal curr:character, 10/newline
-    break-if at-end-of-line?:boolean
-    end:address:duplex-list <- next-duplex end:address:duplex-list
+    at-end-of-text?:boolean <- 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
+    break-if at-end-of-line?
+    end <- next-duplex end
     loop
   }
   # snip it out
-  start-next:address:address:duplex-list <- get-address start:address:duplex-list/lookup, next:offset
-  start-next:address:address:duplex-list/lookup <- copy end:address:duplex-list
+  start-next:address:address:duplex-list <- get-address *start, next:offset
+  *start-next <- copy end
   {
-    break-unless end:address:duplex-list
-    end-prev:address:address:duplex-list <- get-address end:address:duplex-list/lookup, prev:offset
-    end-prev:address:address:duplex-list/lookup <- copy start:address:duplex-list
+    break-unless end
+    end-prev:address:address:duplex-list <- get-address *end, prev:offset
+    *end-prev <- copy start
   }
 ]
 
@@ -1213,38 +1213,38 @@ recipe render-all [
   local-scope
   screen:address <- next-ingredient
   env:address:programming-environment-data <- next-ingredient
-  screen:address <- render-recipes screen:address, env:address:programming-environment-data, 1/clear-below
-  screen:address <- render-sandbox-side screen:address, env:address:programming-environment-data, 1/clear-below
-  recipes:address:editor-data <- get env:address:programming-environment-data/lookup, recipes:offset
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
-  sandbox-in-focus?:boolean <- get env:address:programming-environment-data/lookup, sandbox-in-focus?:offset
-  update-cursor screen:address, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:boolean
-  show-screen screen:address
-  reply screen:address/same-as-ingredient:0
+  screen <- render-recipes screen, env, 1/clear-below
+  screen <- render-sandbox-side screen, env, 1/clear-below
+  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
+  update-cursor screen, recipes, current-sandbox, sandbox-in-focus?
+  show-screen screen
+  reply screen/same-as-ingredient:0
 ]
 
 recipe render-minimal [
   local-scope
   screen:address <- next-ingredient
   env:address:programming-environment-data <- next-ingredient
-  recipes:address:editor-data <- get env:address:programming-environment-data/lookup, recipes:offset
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
-  sandbox-in-focus?:boolean <- get env:address:programming-environment-data/lookup, sandbox-in-focus?:offset
+  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
   {
-    break-if sandbox-in-focus?:boolean
-    screen:address <- render-recipes screen:address, env:address:programming-environment-data
-    cursor-row:number <- get recipes:address:editor-data/lookup, cursor-row:offset
-    cursor-column:number <- get recipes:address:editor-data/lookup, cursor-column:offset
+    break-if sandbox-in-focus?
+    screen <- render-recipes screen, env
+    cursor-row:number <- get *recipes, cursor-row:offset
+    cursor-column:number <- get *recipes, cursor-column:offset
   }
   {
-    break-unless sandbox-in-focus?:boolean
-    screen:address <- render-sandbox-side screen:address, env:address:programming-environment-data
-    cursor-row:number <- get current-sandbox:address:editor-data/lookup, cursor-row:offset
-    cursor-column:number <- get current-sandbox:address:editor-data/lookup, cursor-column:offset
+    break-unless sandbox-in-focus?
+    screen <- render-sandbox-side screen, env
+    cursor-row:number <- get *current-sandbox, cursor-row:offset
+    cursor-column:number <- get *current-sandbox, cursor-column:offset
   }
-  move-cursor screen:address, cursor-row:number, cursor-column:number
-  show-screen screen:address
-  reply screen:address/same-as-ingredient:0
+  move-cursor screen, cursor-row, cursor-column
+  show-screen screen
+  reply screen/same-as-ingredient:0
 ]
 
 recipe render-recipes [
@@ -1252,40 +1252,40 @@ recipe render-recipes [
   screen:address <- next-ingredient
   env:address:programming-environment-data <- next-ingredient
   clear:boolean <- next-ingredient
-  recipes:address:editor-data <- get env:address:programming-environment-data/lookup, recipes:offset
+  recipes:address:editor-data <- get *env, recipes:offset
   # render recipes
-  left:number <- get recipes:address:editor-data/lookup, left:offset
-  right:number <- get recipes:address:editor-data/lookup, right:offset
-  row:number, screen:address <- render screen:address, recipes:address:editor-data
-  recipe-warnings:address:array:character <- get env:address:programming-environment-data/lookup, recipe-warnings:offset
+  left:number <- get *recipes, left:offset
+  right:number <- get *recipes, right:offset
+  row:number, screen <- render screen, recipes
+  recipe-warnings:address:array:character <- get *env, recipe-warnings:offset
   {
     # print any warnings
-    break-unless recipe-warnings:address:array:character
-    row:number, screen:address <- render-string screen:address, recipe-warnings:address:array:character, left:number, right:number, 1/red, row:number
+    break-unless recipe-warnings
+    row, screen <- render-string screen, recipe-warnings, left, right, 1/red, row
   }
   {
     # no warnings? move to next line
-    break-if recipe-warnings:address:array:character
-    row:number <- add row:number, 1
+    break-if recipe-warnings
+    row <- add row, 1
   }
   # draw dotted line after recipes
-  draw-horizontal screen:address, row:number, left:number, right:number, 9480/horizontal-dotted
+  draw-horizontal screen, row, left, right, 9480/horizontal-dotted
   # clear next line, in case we just processed a backspace
-  row:number <- add row:number, 1
-  move-cursor screen:address, row:number, left:number
-  clear-line-delimited screen:address, left:number, right:number
+  row <- add row, 1
+  move-cursor screen, row, left
+  clear-line-delimited screen, left, right
   # clear rest of screen in this column, if requested
-  reply-unless clear:boolean, screen:address/same-as-ingredient:0
-  screen-height:number <- screen-height screen:address
+  reply-unless clear, screen/same-as-ingredient:0
+  screen-height:number <- screen-height screen
   {
-    at-bottom-of-screen?:boolean <- greater-or-equal row:number, screen-height:number
-    break-if at-bottom-of-screen?:boolean
-    move-cursor screen:address, row:number, left:number
-    clear-line-delimited screen:address, left:number, right:number
-    row:number <- add row:number, 1
+    at-bottom-of-screen?:boolean <- greater-or-equal row, screen-height
+    break-if at-bottom-of-screen?
+    move-cursor screen, row, left
+    clear-line-delimited screen, left, right
+    row <- add row, 1
     loop
   }
-  reply screen:address/same-as-ingredient:0
+  reply screen/same-as-ingredient:0
 ]
 
 recipe update-cursor [
@@ -1295,20 +1295,20 @@ recipe update-cursor [
   current-sandbox:address:editor-data <- next-ingredient
   sandbox-in-focus?:boolean <- next-ingredient
   {
-    break-if sandbox-in-focus?:boolean
+    break-if sandbox-in-focus?
 #?     $print [recipes in focus
 #? ] #? 1
-    cursor-row:number <- get recipes:address:editor-data/lookup, cursor-row:offset
-    cursor-column:number <- get recipes:address:editor-data/lookup, cursor-column:offset
+    cursor-row:number <- get *recipes, cursor-row:offset
+    cursor-column:number <- get *recipes, cursor-column:offset
   }
   {
-    break-unless sandbox-in-focus?:boolean
+    break-unless sandbox-in-focus?
 #?     $print [sandboxes in focus
 #? ] #? 1
-    cursor-row:number <- get current-sandbox:address:editor-data/lookup, cursor-row:offset
-    cursor-column:number <- get current-sandbox:address:editor-data/lookup, cursor-column:offset
+    cursor-row:number <- get *current-sandbox, cursor-row:offset
+    cursor-column:number <- get *current-sandbox, cursor-column:offset
   }
-  move-cursor screen:address, cursor-row:number, cursor-column:number
+  move-cursor screen, cursor-row, cursor-column
 ]
 
 scenario editor-handles-empty-event-queue [
@@ -1335,8 +1335,8 @@ scenario editor-handles-mouse-clicks [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1358,8 +1358,8 @@ scenario editor-handles-mouse-clicks-outside-text [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # cursor row
@@ -1377,8 +1377,8 @@ def]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # cursor row
@@ -1396,8 +1396,8 @@ def]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2  # cursor row
@@ -1416,8 +1416,8 @@ scenario editor-handles-mouse-clicks-outside-column [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1603,8 +1603,8 @@ scenario editor-wraps-cursor-after-inserting-characters [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1628,8 +1628,8 @@ scenario editor-wraps-cursor-after-inserting-characters-2 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1724,8 +1724,8 @@ ef]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor should be below start of previous line
   memory-should-contain [
@@ -1746,8 +1746,8 @@ scenario editor-handles-backspace-key [
   replace-in-console 171/«, 3:event/backspace
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1877,8 +1877,8 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -1904,8 +1904,8 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -1917,8 +1917,8 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-2 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -1936,8 +1936,8 @@ scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-3 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   screen-should-contain [
     .          .
@@ -2004,8 +2004,8 @@ d]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -2106,8 +2106,8 @@ scenario editor-moves-across-screen-lines-across-wrap-with-left-arrow [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1  # previous row
@@ -2126,8 +2126,8 @@ def]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -2146,8 +2146,8 @@ def]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # ..and ends at (2, 0)
   memory-should-contain [
@@ -2167,8 +2167,8 @@ def]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 1
@@ -2187,8 +2187,8 @@ de]
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     3 <- 2
@@ -2210,8 +2210,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-a [
   replace-in-console 97/a, 3:event/ctrl-a
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -2234,8 +2234,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-a-2 [
   replace-in-console 97/a, 3:event/ctrl-a
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -2256,8 +2256,8 @@ scenario editor-moves-to-start-of-line-with-home [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -2278,8 +2278,8 @@ scenario editor-moves-to-start-of-line-with-home-2 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to start of line
   memory-should-contain [
@@ -2302,8 +2302,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-e [
   replace-in-console 101/e, 3:event/ctrl-e
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -2316,8 +2316,8 @@ scenario editor-moves-to-start-of-line-with-ctrl-e [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   memory-should-contain [
     4 <- 1
@@ -2345,8 +2345,8 @@ scenario editor-moves-to-end-of-line-with-ctrl-e-2 [
   replace-in-console 101/e, 3:event/ctrl-e
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    4:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    5:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    4:number <- get *2:address:editor-data, cursor-row:offset
+    5:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -2367,8 +2367,8 @@ scenario editor-moves-to-end-of-line-with-end [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -2389,8 +2389,8 @@ scenario editor-moves-to-end-of-line-with-end-2 [
   ]
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
-    3:number <- get 2:address:editor-data/lookup, cursor-row:offset
-    4:number <- get 2:address:editor-data/lookup, cursor-column:offset
+    3:number <- get *2:address:editor-data, cursor-row:offset
+    4:number <- get *2:address:editor-data, cursor-column:offset
   ]
   # cursor moves to end of line
   memory-should-contain [
@@ -2630,10 +2630,10 @@ scenario point-at-multiple-editors [
   # check cursor column in each
   run [
     event-loop screen:address, console:address, 3:address:programming-environment-data
-    4:address:editor-data <- get 3:address:programming-environment-data/lookup, recipes:offset
-    5:number <- get 4:address:editor-data/lookup, cursor-column:offset
-    6:address:editor-data <- get 3:address:programming-environment-data/lookup, current-sandbox:offset
-    7:number <- get 6:address:editor-data/lookup, cursor-column:offset
+    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
   ]
   memory-should-contain [
     5 <- 1
@@ -2657,10 +2657,10 @@ scenario edit-multiple-editors [
   ]
   run [
     event-loop screen:address, console:address, 3:address:programming-environment-data
-    4:address:editor-data <- get 3:address:programming-environment-data/lookup, recipes:offset
-    5:number <- get 4:address:editor-data/lookup, cursor-column:offset
-    6:address:editor-data <- get 3:address:programming-environment-data/lookup, current-sandbox:offset
-    7:number <- get 6:address:editor-data/lookup, cursor-column:offset
+    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
   ]
   screen-should-contain [
     .           run (F4)           .  # this line has a different background, but we don't test that yet
@@ -2829,57 +2829,57 @@ scenario run-and-show-results [
 recipe run-sandboxes [
   local-scope
   env:address:programming-environment-data <- next-ingredient
-  recipes:address:editor-data <- get env:address:programming-environment-data/lookup, recipes:offset
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
+  recipes:address:editor-data <- get *env, recipes:offset
+  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
   # copy code from recipe editor, persist, load into mu, save any warnings
-  in:address:array:character <- editor-contents recipes:address:editor-data
-  save [recipes.mu], in:address:array:character
-  recipe-warnings:address:address:array:character <- get-address env:address:programming-environment-data/lookup, recipe-warnings:offset
-  recipe-warnings:address:address:array:character/lookup <- reload in:address:array:character
+  in:address:array:character <- editor-contents recipes
+  save [recipes.mu], in
+  recipe-warnings:address:address:array:character <- get-address *env, recipe-warnings:offset
+  *recipe-warnings <- reload in
   # if recipe editor has errors, stop
-  reply-if recipe-warnings:address:address:array:character/lookup
+  reply-if *recipe-warnings
   # check contents of right editor (sandbox)
   {
-    sandbox-contents:address:array:character <- editor-contents current-sandbox:address:editor-data
-    break-unless sandbox-contents:address:array:character
+    sandbox-contents:address:array:character <- 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
-    data:address:address:array:character <- get-address new-sandbox:address:sandbox-data/lookup, data:offset
-    data:address:address:array:character/lookup <- copy sandbox-contents:address:array:character
+    data:address:address:array:character <- get-address *new-sandbox, data:offset
+    *data <- copy sandbox-contents
     # push to head of sandbox list
-    dest:address:address:sandbox-data <- get-address env:address:programming-environment-data/lookup, sandbox:offset
-    next:address:address:sandbox-data <- get-address new-sandbox:address:sandbox-data/lookup, next-sandbox:offset
-    next:address:address:sandbox-data/lookup <- copy dest:address:address:sandbox-data/lookup
-    dest:address:address:sandbox-data/lookup <- copy new-sandbox:address:sandbox-data
+    dest:address:address:sandbox-data <- get-address *env, sandbox:offset
+    next:address:address:sandbox-data <- get-address *new-sandbox, next-sandbox:offset
+    *next <- copy *dest
+    *dest <- copy new-sandbox
     # clear sandbox editor
-    init:address:address:duplex-list <- get-address current-sandbox:address:editor-data/lookup, data:offset
-    init:address:address:duplex-list/lookup <- push-duplex 167/§, 0/tail
+    init:address:address:duplex-list <- get-address *current-sandbox, data:offset
+    *init <- push-duplex 167/§, 0/tail
   }
   # save all sandboxes before running, just in case we die when running
   # first clear previous versions, in case we deleted some sandbox
   $system [rm lesson/[0-9]*]
-  curr:address:sandbox-data <- get env:address:programming-environment-data/lookup, sandbox:offset
+  curr:address:sandbox-data <- get *env, sandbox:offset
   filename:number <- copy 0
   {
-    break-unless curr:address:sandbox-data
-    data:address:address:array:character <- get-address curr:address:sandbox-data/lookup, data:offset
-    save filename:number, data:address:address:array:character/lookup
-    filename:number <- add filename:number, 1
-    curr:address:sandbox-data <- get curr:address:sandbox-data/lookup, next-sandbox:offset
+    break-unless curr
+    data:address:address:array:character <- get-address *curr, data:offset
+    save filename, *data
+    filename <- add filename, 1
+    curr <- get *curr, next-sandbox:offset
     loop
   }
   # run all sandboxes
-  curr:address:sandbox-data <- get env:address:programming-environment-data/lookup, sandbox:offset
+  curr <- get *env, sandbox:offset
   {
-    break-unless curr:address:sandbox-data
-    data:address:address:array:character <- get-address curr:address:sandbox-data/lookup, data:offset
-    response:address:address:array:character <- get-address curr:address:sandbox-data/lookup, response:offset
-    warnings:address:address:array:character <- get-address curr:address:sandbox-data/lookup, warnings:offset
-    fake-screen:address:address:screen <- get-address curr:address:sandbox-data/lookup, screen:offset
-    response:address:address:array:character/lookup, warnings:address:address:array:character/lookup, fake-screen:address:address:screen/lookup <- run-interactive data:address:address:array:character/lookup
-#?     $print warnings:address:address:array:character/lookup, [ ], warnings:address:address:array:character/lookup/lookup, 10/newline
-    curr:address:sandbox-data <- get curr:address:sandbox-data/lookup, next-sandbox:offset
+    break-unless curr
+    data <- get-address *curr, data:offset
+    response:address:address:array:character <- get-address *curr, response:offset
+    warnings:address:address:array:character <- get-address *curr, warnings:offset
+    fake-screen:address:address:screen <- get-address *curr, screen:offset
+    *response, *warnings, *fake-screen <- run-interactive *data
+#?     $print *warnings, [ ], **warnings, 10/newline
+    curr <- get *curr, next-sandbox:offset
     loop
   }
 ]
@@ -2890,29 +2890,29 @@ recipe render-sandbox-side [
   env:address:programming-environment-data <- next-ingredient
   clear:boolean <- next-ingredient
 #?   trace [app], [render sandbox side] #? 1
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
-  left:number <- get current-sandbox:address:editor-data/lookup, left:offset
-  right:number <- get current-sandbox:address:editor-data/lookup, right:offset
-  row:number, screen:address <- render screen:address, current-sandbox:address:editor-data
-  row:number <- add row:number, 1
-  draw-horizontal screen:address, row:number, left:number, right:number, 9473/horizontal-double
-  sandbox:address:sandbox-data <- get env:address:programming-environment-data/lookup, sandbox:offset
-  row:number, screen:address <- render-sandboxes screen:address, sandbox:address:sandbox-data, left:number, right:number, row:number
+  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, screen <- render screen, current-sandbox
+  row <- add row, 1
+  draw-horizontal screen, row, left, right, 9473/horizontal-double
+  sandbox:address:sandbox-data <- get *env, sandbox:offset
+  row, screen <- render-sandboxes screen, sandbox, left, right, row
   # clear next line, in case we just processed a backspace
-  row:number <- add row:number, 1
-  move-cursor screen:address, row:number, left:number
-  clear-line-delimited screen:address, left:number, right:number
-  reply-unless clear:boolean, screen:address/same-as-ingredient:0
-  screen-height:number <- screen-height screen:address
+  row <- add row, 1
+  move-cursor screen, row, left
+  clear-line-delimited screen, left, right
+  reply-unless clear, screen/same-as-ingredient:0
+  screen-height:number <- screen-height screen
   {
-    at-bottom-of-screen?:boolean <- greater-or-equal row:number, screen-height:number
-    break-if at-bottom-of-screen?:boolean
-    move-cursor screen:address, row:number, left:number
-    clear-line-delimited screen:address, left:number, right:number
-    row:number <- add row:number, 1
+    at-bottom-of-screen?:boolean <- greater-or-equal row, screen-height
+    break-if at-bottom-of-screen?
+    move-cursor screen, row, left
+    clear-line-delimited screen, left, right
+    row <- add row, 1
     loop
   }
-  reply screen:address/same-as-ingredient:0
+  reply screen/same-as-ingredient:0
 ]
 
 recipe render-sandboxes [
@@ -2922,49 +2922,49 @@ recipe render-sandboxes [
   left:number <- next-ingredient
   right:number <- next-ingredient
   row:number <- next-ingredient
-  reply-unless sandbox:address:sandbox-data, row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
-  screen-height:number <- screen-height screen:address
-  at-bottom?:boolean <- greater-or-equal row:number screen-height:number
-  reply-if at-bottom?:boolean, row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
-#?   $print [rendering sandbox ], sandbox:address:sandbox-data, 10/newline
+  reply-unless sandbox, row/same-as-ingredient:4, screen/same-as-ingredient:0
+  screen-height:number <- screen-height screen
+  at-bottom?:boolean <- greater-or-equal row, screen-height
+  reply-if at-bottom?:boolean, row/same-as-ingredient:4, screen/same-as-ingredient:0
+#?   $print [rendering sandbox ], sandbox, 10/newline
   # render sandbox menu
-  row:number <- add row:number, 1
-  move-cursor screen:address, row:number, left:number
-  clear-line-delimited screen:address, left:number, right:number
-  print-character screen:address, 120/x, 245/grey
+  row <- add row, 1
+  move-cursor screen, row, left
+  clear-line-delimited screen, left, right
+  print-character screen, 120/x, 245/grey
   # save menu row so we can detect clicks to it later
-  starting-row:address:number <- get-address sandbox:address:sandbox-data/lookup, starting-row-on-screen:offset
-  starting-row:address:number/lookup <- copy row:number
+  starting-row:address:number <- get-address *sandbox, starting-row-on-screen:offset
+  *starting-row <- copy row
   # render sandbox contents
-  sandbox-data:address:array:character <- get sandbox:address:sandbox-data/lookup, data:offset
-  row:number, screen:address <- render-string screen:address, sandbox-data:address:array:character, left:number, right:number, 7/white, row:number
+  sandbox-data:address:array:character <- get *sandbox, data:offset
+  row, screen <- render-string screen, sandbox-data, left, right, 7/white, row
   # render sandbox warnings, screen or response, in that order
-  sandbox-response:address:array:character <- get sandbox:address:sandbox-data/lookup, response:offset
-  sandbox-warnings:address:array:character <- get sandbox:address:sandbox-data/lookup, warnings:offset
-  sandbox-screen:address <- get sandbox:address:sandbox-data/lookup, screen:offset
+  sandbox-response:address:array:character <- get *sandbox, response:offset
+  sandbox-warnings:address:array:character <- get *sandbox, warnings:offset
+  sandbox-screen:address <- get *sandbox, screen:offset
   {
-    break-unless sandbox-warnings:address:array:character
-    row:number, screen:address <- render-string screen:address, sandbox-warnings:address:array:character, left:number, right:number, 1/red, row:number
+    break-unless sandbox-warnings
+    row, screen <- render-string screen, sandbox-warnings, left, right, 1/red, row
   }
   {
-    break-if sandbox-warnings:address:array:character
-    empty-screen?:boolean <- fake-screen-is-clear? sandbox-screen:address
-    break-if empty-screen?:boolean
-    row:number, screen:address <- render-screen screen:address, sandbox-screen:address, left:number, right:number, row:number
+    break-if sandbox-warnings
+    empty-screen?:boolean <- fake-screen-is-clear? sandbox-screen
+    break-if empty-screen?
+    row, screen <- render-screen screen, sandbox-screen, left, right, row
   }
   {
-    break-if sandbox-warnings:address:array:character
-    break-unless empty-screen?:boolean
-    row:number, screen:address <- render-string screen:address, sandbox-response:address:array:character, left:number, right:number, 245/grey, row:number
+    break-if sandbox-warnings
+    break-unless empty-screen?
+    row, screen <- render-string screen, sandbox-response, left, right, 245/grey, row
   }
-  at-bottom?:boolean <- greater-or-equal row:number screen-height:number
-  reply-if at-bottom?:boolean, row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
+  at-bottom?:boolean <- greater-or-equal row, screen-height
+  reply-if at-bottom?, row/same-as-ingredient:4, screen/same-as-ingredient:0
   # draw solid line after sandbox
-  draw-horizontal screen:address, row:number, left:number, right:number, 9473/horizontal-double
+  draw-horizontal screen, row, left, right, 9473/horizontal-double
   # draw next sandbox
-  next-sandbox:address:sandbox-data <- get sandbox:address:sandbox-data/lookup, next-sandbox:offset
-  row:number, screen:address <- render-sandboxes screen:address, next-sandbox:address:sandbox-data, left:number, right:number, row:number
-  reply row:number/same-as-ingredient:4, screen:address/same-as-ingredient:0
+  next-sandbox:address:sandbox-data <- get *sandbox, next-sandbox:offset
+  row, screen <- render-sandboxes screen, next-sandbox, left, right, row
+  reply row/same-as-ingredient:4, screen/same-as-ingredient:0
 ]
 
 # assumes programming environment has no sandboxes; restores them from previous session
@@ -2973,21 +2973,21 @@ recipe restore-sandboxes [
   env:address:programming-environment-data <- next-ingredient
   # read all scenarios, pushing them to end of a list of scenarios
   filename:number <- copy 0
-  curr:address:address:sandbox-data <- get-address env:address:programming-environment-data/lookup, sandbox:offset
+  curr:address:address:sandbox-data <- get-address *env, sandbox:offset
   {
-    contents:address:array:character <- restore filename:number
-    break-unless contents:address:array:character  # stop at first error; assuming file didn't exist
-#?     $print contents:address:array:character, 10/newline
+    contents:address:array:character <- restore filename
+    break-unless contents  # stop at first error; assuming file didn't exist
+#?     $print contents, 10/newline
     # create new sandbox for file
-    curr:address:address:sandbox-data/lookup <- new sandbox-data:type
-    data:address:address:array:character <- get-address curr:address:address:sandbox-data/lookup/lookup, data:offset
-    data:address:address:array:character/lookup <- copy contents:address:array:character
+    *curr <- new sandbox-data:type
+    data:address:address:array:character <- get-address **curr, data:offset
+    *data <- copy contents
     # increment loop variables
-    filename:number <- add filename:number, 1
-    curr:address:address:sandbox-data <- get-address curr:address:address:sandbox-data/lookup/lookup, next-sandbox:offset
+    filename <- add filename, 1
+    curr <- get-address **curr, next-sandbox:offset
     loop
   }
-  reply env:address:programming-environment-data/same-as-ingredient:0
+  reply env/same-as-ingredient:0
 ]
 
 # was-deleted?:boolean <- delete-sandbox t:touch-event, env:address:programming-environment-data
@@ -2995,40 +2995,40 @@ recipe delete-sandbox [
   local-scope
   t:touch-event <- next-ingredient
   env:address:programming-environment-data <- next-ingredient
-  click-column:number <- get t:touch-event, column:offset
-  current-sandbox:address:editor-data <- get env:address:programming-environment-data/lookup, current-sandbox:offset
-  right:number <- get current-sandbox:address:editor-data/lookup, right:offset
-#?   $print [comparing column ], click-column:number, [ vs ], right:number, 10/newline
-  at-right?:boolean <- equal click-column:number, right:number
-  reply-unless at-right?:boolean, 0/false
+  click-column:number <- get t, column:offset
+  current-sandbox:address:editor-data <- get *env, current-sandbox:offset
+  right:number <- get *current-sandbox, right:offset
+#?   $print [comparing column ], click-column, [ vs ], right, 10/newline
+  at-right?:boolean <- equal click-column, right
+  reply-unless at-right?, 0/false
 #?   $print [trying to delete
 #? ] #? 1
-  click-row:number <- get t:touch-event, row:offset
-  prev:address:address:sandbox-data <- get-address env:address:programming-environment-data/lookup, sandbox:offset
-#?   $print [prev: ], prev:address:address:sandbox-data, [ -> ], prev:address:address:sandbox-data/lookup, 10/newline
-  curr:address:sandbox-data <- get env:address:programming-environment-data/lookup, sandbox:offset
+  click-row:number <- get t, row:offset
+  prev:address:address:sandbox-data <- get-address *env, sandbox:offset
+#?   $print [prev: ], prev, [ -> ], *prev, 10/newline
+  curr:address:sandbox-data <- get *env, sandbox:offset
   {
 #?     $print [next sandbox
 #? ] #? 1
-    break-unless curr:address:sandbox-data
+    break-unless curr
     # more sandboxes to check
     {
 #?       $print [checking
 #? ] #? 1
-      target-row:number <- get curr:address:sandbox-data/lookup, starting-row-on-screen:offset
-#?       $print [comparing row ], target-row:number, [ vs ], click-row:number, 10/newline
-      delete-curr?:boolean <- equal target-row:number, click-row:number
-      break-unless delete-curr?:boolean
+      target-row:number <- get *curr, starting-row-on-screen:offset
+#?       $print [comparing row ], target-row, [ vs ], click-row, 10/newline
+      delete-curr?:boolean <- equal target-row, click-row
+      break-unless delete-curr?
 #?       $print [found!
 #? ] #? 1
       # delete this sandbox, rerender and stop
-      prev:address:address:sandbox-data/lookup <- get curr:address:sandbox-data/lookup, next-sandbox:offset
-#?       $print [setting prev: ], prev:address:address:sandbox-data, [ -> ], prev:address:address:sandbox-data/lookup, 10/newline
+      *prev <- get *curr, next-sandbox:offset
+#?       $print [setting prev: ], prev, [ -> ], *prev, 10/newline
       reply 1/true
     }
-    prev:address:address:sandbox-data <- get-address curr:address:sandbox-data/lookup, next-sandbox:offset
-#?     $print [prev: ], prev:address:address:sandbox-data, [ -> ], prev:address:address:sandbox-data/lookup, 10/newline
-    curr:address:sandbox-data <- get curr:address:sandbox-data/lookup, next-sandbox:offset
+    prev <- get-address *curr, next-sandbox:offset
+#?     $print [prev: ], prev, [ -> ], *prev, 10/newline
+    curr <- get *curr, next-sandbox:offset
     loop
   }
   reply 0/false
@@ -3277,20 +3277,20 @@ recipe editor-contents [
   local-scope
   editor:address:editor-data <- next-ingredient
   buf:address:buffer <- new-buffer 80
-  curr:address:duplex-list <- get editor:address:editor-data/lookup, data:offset
+  curr:address:duplex-list <- get *editor, data:offset
   # skip § sentinel
-  assert curr:address:duplex-list, [editor without data is illegal; must have at least a sentinel]
-  curr:address:duplex-list <- next-duplex curr:address:duplex-list
-  reply-unless curr:address:duplex-list, 0
+  assert curr, [editor without data is illegal; must have at least a sentinel]
+  curr <- next-duplex curr
+  reply-unless curr, 0
   {
-    break-unless curr:address:duplex-list
-    c:character <- get curr:address:duplex-list/lookup, value:offset
-    buffer-append buf:address:buffer, c:character
-    curr:address:duplex-list <- next-duplex curr:address:duplex-list
+    break-unless curr
+    c:character <- get *curr, value:offset
+    buffer-append buf, c
+    curr <- next-duplex curr
     loop
   }
-  result:address:array:character <- buffer-to-array buf:address:buffer
-  reply result:address:array:character
+  result:address:array:character <- buffer-to-array buf
+  reply result
 ]
 
 scenario editor-provides-edited-contents [
@@ -3304,7 +3304,7 @@ scenario editor-provides-edited-contents [
   run [
     editor-event-loop screen:address, console:address, 2:address:editor-data
     3:address:array:character <- editor-contents 2:address:editor-data
-    4:array:character <- copy 3:address:array:character/lookup
+    4:array:character <- copy *3:address:array:character
   ]
   memory-should-contain [
     4:string <- [abdefc]
@@ -3358,8 +3358,7 @@ scenario run-shows-missing-type-warnings [
   run [
     x:address:array:character <- new [ 
 recipe foo [
-  x:number <- copy 0
-  copy x
+  x <- copy 0
 ]]
     y:address:array:character <- new [foo]
     env:address:programming-environment-data <- new-programming-environment screen:address, x:address:array:character, y:address:array:character
@@ -3369,10 +3368,9 @@ recipe foo [
     .                                                                                 run (F4)           .
     .                                                  ┊foo                                              .
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
-    .  x:number <- copy 0                              ┊                                                 .
-    .  copy x                                          ┊                                                 .
+    .  x <- copy 0                                     ┊                                                 .
     .]                                                 ┊                                                 .
-    .missing type in 'copy x'                          ┊                                                 .
+    .missing type in 'x <- copy 0'                     ┊                                                 .
     .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊                                                 .
     .                                                  ┊                                                 .
   ]
@@ -3418,7 +3416,7 @@ scenario run-shows-non-literal-get-argument-warnings [
 recipe foo [
   x:number <- copy 0
   y:address:point <- new point:type
-  get y:address:point/lookup, x:number
+  get *y:address:point, x:number
 ]]
     y:address:array:character <- new [foo]
     env:address:programming-environment-data <- new-programming-environment screen:address, x:address:array:character, y:address:array:character
@@ -3430,7 +3428,7 @@ recipe foo [
     .recipe foo [                                      ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━.
     .  x:number <- copy 0                              ┊                                                 .
     .  y:address:point <- new point:type               ┊                                                 .
-    .  get y:address:point/lookup, x:number            ┊                                                 .
+    .  get *y:address:point, x:number                  ┊                                                 .
     .]                                                 ┊                                                 .
     .foo: expected ingredient 1 of 'get' to have type ↩┊                                                 .
     .'offset'; got x:number                            ┊                                                 .
@@ -3451,22 +3449,22 @@ recipe draw-box [
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
   # top border
-  draw-horizontal screen:address, top:number, left:number, right:number, color:number
-  draw-horizontal screen:address, bottom:number, left:number, right:number, color:number
-  draw-vertical screen:address, left:number, top:number, bottom:number, color:number
-  draw-vertical screen:address, right:number, top:number, bottom:number, color:number
-  draw-top-left screen:address, top:number, left:number, color:number
-  draw-top-right screen:address, top:number, right:number, color:number
-  draw-bottom-left screen:address, bottom:number, left:number, color:number
-  draw-bottom-right screen:address, bottom:number, right:number, color:number
+  draw-horizontal screen, top, left, right, color
+  draw-horizontal screen, bottom, left, right, color
+  draw-vertical screen, left, top, bottom, color
+  draw-vertical screen, right, top, bottom, color
+  draw-top-left screen, top, left, color
+  draw-top-right screen, top, right, color
+  draw-bottom-left screen, bottom, left, color
+  draw-bottom-right screen, bottom, right, color
   # position cursor inside box
-  move-cursor screen:address, top:number, left:number
-  cursor-down screen:address
-  cursor-right screen:address
+  move-cursor screen, top, left
+  cursor-down screen
+  cursor-right screen
 ]
 
 recipe draw-horizontal [
@@ -3477,26 +3475,26 @@ recipe draw-horizontal [
   right:number <- next-ingredient
   style:character, style-found?:boolean <- next-ingredient
   {
-    break-if style-found?:boolean
-    style:character <- copy 9472/horizontal
+    break-if style-found?
+    style <- copy 9472/horizontal
   }
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
   bg-color:number, bg-color-found?:boolean <- next-ingredient
   {
     break-if bg-color-found?:boolean
-    bg-color:number <- copy 0/black
+    bg-color <- copy 0/black
   }
-  move-cursor screen:address, row:number, x:number
+  move-cursor screen, row, x
   {
-    continue?:boolean <- lesser-or-equal x:number, right:number  # right is inclusive, to match editor-data semantics
-    break-unless continue?:boolean
-    print-character screen:address, style:character, color:number, bg-color:number
-    x:number <- add x:number, 1
+    continue?:boolean <- lesser-or-equal x, right  # right is inclusive, to match editor-data semantics
+    break-unless continue?
+    print-character screen, style, color, bg-color
+    x <- add x, 1
     loop
   }
 ]
@@ -3505,25 +3503,25 @@ recipe draw-vertical [
   local-scope
   screen:address <- next-ingredient
   col:number <- next-ingredient
-  x:number <- next-ingredient
+  y:number <- next-ingredient
   bottom:number <- next-ingredient
   style:character, style-found?:boolean <- next-ingredient
   {
-    break-if style-found?:boolean
-    style:character <- copy 9474/vertical
+    break-if style-found?
+    style <- copy 9474/vertical
   }
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
   {
-    continue?:boolean <- lesser-than x:number, bottom:number
-    break-unless continue?:boolean
-    move-cursor screen:address, x:number, col:number
-    print-character screen:address, style:character, color:number
-    x:number <- add x:number, 1
+    continue?:boolean <- lesser-than y, bottom
+    break-unless continue?
+    move-cursor screen, y, col
+    print-character screen, style, color
+    y <- add y, 1
     loop
   }
 ]
@@ -3536,11 +3534,11 @@ recipe draw-top-left [
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
-  move-cursor screen:address, top:number, left:number
-  print-character screen:address, 9484/down-right, color:number
+  move-cursor screen, top, left
+  print-character screen, 9484/down-right, color
 ]
 
 recipe draw-top-right [
@@ -3551,11 +3549,11 @@ recipe draw-top-right [
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
-  move-cursor screen:address, top:number, right:number
-  print-character screen:address, 9488/down-left, color:number
+  move-cursor screen, top, right
+  print-character screen, 9488/down-left, color
 ]
 
 recipe draw-bottom-left [
@@ -3566,11 +3564,11 @@ recipe draw-bottom-left [
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
-  move-cursor screen:address, bottom:number, left:number
-  print-character screen:address, 9492/up-right, color:number
+  move-cursor screen, bottom, left
+  print-character screen, 9492/up-right, color
 ]
 
 recipe draw-bottom-right [
@@ -3581,11 +3579,11 @@ recipe draw-bottom-right [
   color:number, color-found?:boolean <- next-ingredient
   {
     # default color to white
-    break-if color-found?:boolean
-    color:number <- copy 245/grey
+    break-if color-found?
+    color <- copy 245/grey
   }
-  move-cursor screen:address, bottom:number, right:number
-  print-character screen:address, 9496/up-left, color:number
+  move-cursor screen, bottom, right
+  print-character screen, 9496/up-left, color
 ]
 
 recipe print-string-with-gradient-background [
@@ -3595,24 +3593,24 @@ recipe print-string-with-gradient-background [
   color:number <- next-ingredient
   bg-color1:number <- next-ingredient
   bg-color2:number <- next-ingredient
-  len:number <- length s:address:array:character/lookup
-  color-range:number <- subtract bg-color2:number, bg-color1:number
-  color-quantum:number <- divide color-range:number, len:number
+  len:number <- length *s
+  color-range:number <- subtract bg-color2, bg-color1
+  color-quantum:number <- divide color-range, len
 #?   close-console #? 2
-#?   $print len:number, [, ], color-range:number, [, ], color-quantum:number, 10/newline
+#?   $print len, [, ], color-range, [, ], color-quantum, 10/newline
 #? #?   $exit #? 3
-  bg-color:number <- copy bg-color1:number
+  bg-color:number <- copy bg-color1
   i:number <- copy 0
   {
-    done?:boolean <- greater-or-equal i:number, len:number
-    break-if done?:boolean
-    c:character <- index s:address:array:character/lookup, i:number
-    print-character x:address:screen, c:character, color:number, bg-color:number
-    i:number <- add i:number, 1
-    bg-color:number <- add bg-color:number, color-quantum:number
-#?     $print [=> ], bg-color:number, 10/newline
+    done?:boolean <- greater-or-equal i, len
+    break-if done?
+    c:character <- index *s, i
+    print-character x, c, color, bg-color
+    i <- add i, 1
+    bg-color <- add bg-color, color-quantum
+#?     $print [=> ], bg-color, 10/newline
     loop
   }
 #?   $exit #? 1
-  reply x:address:screen/same-as-ingredient:0
+  reply x/same-as-ingredient:0
 ]
diff --git a/factorial.mu b/factorial.mu
index 23c247e0..31b2f63c 100644
--- a/factorial.mu
+++ b/factorial.mu
@@ -3,7 +3,7 @@
 recipe main [
   local-scope
   x:number <- factorial 5
-  $print [result: ], x:number, [ 
+  $print [result: ], x, [ 
 ]
 ]
 
@@ -12,15 +12,15 @@ recipe factorial [
   n:number <- next-ingredient
   {
     # if n=0 return 1
-    zero?:boolean <- equal n:number, 0
-    break-unless zero?:boolean
+    zero?:boolean <- equal n, 0
+    break-unless zero?
     reply 1
   }
   # return n * factorial(n-1)
-  x:number <- subtract n:number, 1
-  subresult:number <- factorial x:number
-  result:number <- multiply subresult:number, n:number
-  reply result:number
+  x:number <- subtract n, 1
+  subresult:number <- factorial x
+  result:number <- multiply subresult, n
+  reply result
 ]
 
 # unit test
diff --git a/tangle.mu b/tangle.mu
index 121bfbcc..b9d05bee 100644
--- a/tangle.mu
+++ b/tangle.mu
@@ -17,17 +17,17 @@ recipe factorial [
 
 after +base-case [
   # if n=0 return 1
-  zero?:boolean <- equal n:number, 0
-  break-unless zero?:boolean
+  zero?:boolean <- equal n, 0
+  break-unless zero?
   reply 1
 ]
 
 after +recursive-case [
   # return n * factorial(n - 1)
-  x:number <- subtract n:number, 1
-  subresult:number <- factorial x:number
-  result:number <- multiply subresult:number, n:number
-  reply result:number
+  x:number <- subtract n, 1
+  subresult:number <- factorial x
+  result:number <- multiply subresult, n
+  reply result
 ]
 
 recipe main [