2446 - drop '-duplex' namespacing in recipes

Great that it just worked after the previous commit.

6 files changed, 77 insertions, 77 deletions

diff --git a/edit/001-editor.mu b/edit/001-editor.mu
index 4b8da7a8..c74e6ac4 100644
--- a/edit/001-editor.mu
+++ b/edit/001-editor.mu
@@ -64,7 +64,7 @@ recipe new-editor s:address:array:character, screen:address:screen, left:number,
   x <- get-address *result, cursor-column:offset
   *x <- copy left
   init:address:address:duplex-list:character <- get-address *result, data:offset
-  *init <- push-duplex 167/§, 0/tail
+  *init <- push 167/§, 0/tail
   top-of-screen:address:address:duplex-list:character <- get-address *result, top-of-screen:offset
   *top-of-screen <- copy *init
   y:address:address:duplex-list:character <- get-address *result, before-cursor:offset
@@ -92,9 +92,9 @@ recipe insert-text editor:address:editor-data, text:address:array:character -> e
     done?:boolean <- greater-or-equal idx, len
     break-if done?
     c:character <- index *text, idx
-    insert-duplex c, curr
+    insert c, curr
     # next iter
-    curr <- next-duplex curr
+    curr <- next curr
     idx <- add idx, 1
     loop
   }
@@ -136,8 +136,8 @@ recipe render screen:address:screen, editor:address:editor-data -> last-row:numb
   right:number <- get *editor, right:offset
   # traversing editor
   curr:address:duplex-list:character <- get *editor, top-of-screen:offset
-  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev-duplex
-  curr <- next-duplex curr
+  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev
+  curr <- next curr
   # traversing screen
   +render-loop-initialization
   color:number <- copy 7/white
@@ -175,7 +175,7 @@ recipe render screen:address:screen, editor:address:editor-data -> last-row:numb
         left-of-cursor?:boolean <- lesser-than column, *cursor-column
         break-unless left-of-cursor?
         *cursor-column <- copy column
-        *before-cursor <- prev-duplex curr
+        *before-cursor <- prev curr
       }
       # clear rest of line in this window
       clear-line-delimited screen, column, right
@@ -183,8 +183,8 @@ recipe render screen:address:screen, editor:address:editor-data -> last-row:numb
       row <- add row, 1
       column <- copy left
       screen <- move-cursor screen, row, column
-      curr <- next-duplex curr
-      prev <- next-duplex prev
+      curr <- next curr
+      prev <- next prev
       loop +next-character:label
     }
     {
@@ -201,8 +201,8 @@ recipe render screen:address:screen, editor:address:editor-data -> last-row:numb
       loop +next-character:label
     }
     print-character screen, c, color
-    curr <- next-duplex curr
-    prev <- next-duplex prev
+    curr <- next curr
+    prev <- next prev
     column <- add column, 1
     loop
   }
diff --git a/edit/002-typing.mu b/edit/002-typing.mu
index e766926a..bc47e2d8 100644
--- a/edit/002-typing.mu
+++ b/edit/002-typing.mu
@@ -79,8 +79,8 @@ recipe snap-cursor screen:address:screen, editor:address:editor-data, target-row
   screen-height:number <- screen-height screen
   # count newlines until screen row
   curr:address:duplex-list:character <- get *editor, top-of-screen:offset
-  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev-duplex
-  curr <- next-duplex curr
+  prev:address:duplex-list:character <- copy curr  # just in case curr becomes null and we can't compute prev
+  curr <- next curr
   row:number <- copy 1/top
   column:number <- copy left
   cursor-row:address:number <- get-address *editor, cursor-row:offset
@@ -120,8 +120,8 @@ recipe snap-cursor screen:address:screen, editor:address:editor-data, target-row
       # skip to next line
       row <- add row, 1
       column <- copy left
-      curr <- next-duplex curr
-      prev <- next-duplex prev
+      curr <- next curr
+      prev <- next prev
       loop +next-character:label
     }
     {
@@ -134,8 +134,8 @@ recipe snap-cursor screen:address:screen, editor:address:editor-data, target-row
       # don't increment curr/prev
       loop +next-character:label
     }
-    curr <- next-duplex curr
-    prev <- next-duplex prev
+    curr <- next curr
+    prev <- next prev
     column <- add column, 1
     loop
   }
@@ -199,8 +199,8 @@ recipe insert-at-cursor editor:address:editor-data, c:character, screen:address:
   local-scope
   load-ingredients
   before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset
-  insert-duplex c, *before-cursor
-  *before-cursor <- next-duplex *before-cursor
+  insert c, *before-cursor
+  *before-cursor <- next *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
@@ -213,7 +213,7 @@ recipe insert-at-cursor editor:address:editor-data, c:character, screen:address:
   <insert-character-special-case>
   # but mostly we'll just move the cursor right
   *cursor-column <- add *cursor-column, 1
-  next:address:duplex-list:character <- next-duplex *before-cursor
+  next:address:duplex-list:character <- next *before-cursor
   {
     # at end of all text? no need to scroll? just print the character and leave
     at-end?:boolean <- equal next, 0/null
@@ -248,7 +248,7 @@ recipe insert-at-cursor editor:address:editor-data, c:character, screen:address:
       break-if at-newline?
       print-character screen, currc
       curr-column <- add curr-column, 1
-      curr <- next-duplex curr
+      curr <- next curr
       loop
     }
     go-render? <- copy 0/false
@@ -832,8 +832,8 @@ recipe insert-new-line-and-indent editor:address:editor-data, screen:address:scr
   right:number <- get *editor, right:offset
   screen-height:number <- screen-height screen
   # insert newline
-  insert-duplex 10/newline, *before-cursor
-  *before-cursor <- next-duplex *before-cursor
+  insert 10/newline, *before-cursor
+  *before-cursor <- next *before-cursor
   *cursor-row <- add *cursor-row, 1
   *cursor-column <- copy left
   # maybe scroll
@@ -848,7 +848,7 @@ recipe insert-new-line-and-indent editor:address:editor-data, screen:address:scr
   indent?:boolean <- get *editor, indent?:offset
   reply-unless indent?
   d:address:duplex-list:character <- get *editor, data:offset
-  end-of-previous-line:address:duplex-list:character <- prev-duplex *before-cursor
+  end-of-previous-line:address:duplex-list:character <- prev *before-cursor
   indent:number <- line-indent end-of-previous-line, d
   i:number <- copy 0
   {
@@ -870,7 +870,7 @@ recipe line-indent curr:address:duplex-list:character, start:address:duplex-list
   at-start?:boolean <- equal curr, start
   reply-if at-start?
   {
-    curr <- prev-duplex curr
+    curr <- prev curr
     break-unless curr
     at-start?:boolean <- equal curr, start
     break-if at-start?
diff --git a/edit/003-shortcuts.mu b/edit/003-shortcuts.mu
index f4c480d3..9c46c927 100644
--- a/edit/003-shortcuts.mu
+++ b/edit/003-shortcuts.mu
@@ -85,14 +85,14 @@ recipe delete-before-cursor editor:address:editor-data, screen:address:screen ->
   load-ingredients
   before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset
   # if at start of text (before-cursor at § sentinel), return
-  prev:address:duplex-list:character <- prev-duplex *before-cursor
+  prev:address:duplex-list:character <- prev *before-cursor
   go-render?, backspaced-cell <- copy 0/no-more-render, 0/nothing-deleted
   reply-unless prev
   trace 10, [app], [delete-before-cursor]
   original-row:number <- get *editor, cursor-row:offset
   editor, scroll?:boolean <- move-cursor-coordinates-left editor
   backspaced-cell:address:duplex-list:character <- copy *before-cursor
-  remove-duplex *before-cursor  # will also neatly trim next/prev pointers in backspaced-cell/*before-cursor
+  remove *before-cursor  # will also neatly trim next/prev pointers in backspaced-cell/*before-cursor
   *before-cursor <- copy prev
   go-render? <- copy 1/true
   reply-if scroll?
@@ -105,7 +105,7 @@ recipe delete-before-cursor editor:address:editor-data, screen:address:screen ->
   reply-unless same-row?
   left:number <- get *editor, left:offset
   right:number <- get *editor, right:offset
-  curr:address:duplex-list:character <- next-duplex *before-cursor
+  curr:address:duplex-list:character <- next *before-cursor
   screen <- move-cursor screen, cursor-row, cursor-column
   curr-column:number <- copy cursor-column
   {
@@ -120,7 +120,7 @@ recipe delete-before-cursor editor:address:editor-data, screen:address:screen ->
     break-if at-newline?
     screen <- print-character screen, currc
     curr-column <- add curr-column, 1
-    curr <- next-duplex curr
+    curr <- next curr
     loop
   }
   # we're guaranteed not to be at the right margin
@@ -184,7 +184,7 @@ recipe previous-line-length curr:address:duplex-list:character, start:address:du
   at-start?:boolean <- equal curr, start
   reply-if at-start?
   {
-    curr <- prev-duplex curr
+    curr <- prev curr
     break-unless curr
     at-start?:boolean <- equal curr, start
     break-if at-start?
@@ -333,16 +333,16 @@ recipe delete-at-cursor editor:address:editor-data, screen:address:screen -> edi
   local-scope
   load-ingredients
   before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset
-  deleted-cell:address:duplex-list:character <- next-duplex *before-cursor
+  deleted-cell:address:duplex-list:character <- next *before-cursor
   go-render? <- copy 0/false
   reply-unless deleted-cell
   currc:character <- get *deleted-cell, value:offset
-  remove-duplex deleted-cell
+  remove deleted-cell
   deleted-newline?:boolean <- equal currc, 10/newline
   go-render? <- copy 1/true
   reply-if deleted-newline?
   # wasn't a newline? render rest of line
-  curr:address:duplex-list:character <- next-duplex *before-cursor  # refresh after remove-duplex above
+  curr:address:duplex-list:character <- next *before-cursor  # refresh after remove above
   cursor-row:address:number <- get-address *editor, cursor-row:offset
   cursor-column:address:number <- get-address *editor, cursor-column:offset
   screen <- move-cursor screen, *cursor-row, *cursor-column
@@ -360,7 +360,7 @@ recipe delete-at-cursor editor:address:editor-data, screen:address:screen -> edi
     break-if at-newline?
     screen <- print-character screen, currc
     curr-column <- add curr-column, 1
-    curr <- next-duplex curr
+    curr <- next curr
     loop
   }
   # we're guaranteed not to be at the right margin
@@ -397,7 +397,7 @@ after <handle-special-key> [
     move-to-next-character?:boolean <- equal *k, 65514/right-arrow
     break-unless move-to-next-character?
     # if not at end of text
-    next-cursor:address:duplex-list:character <- next-duplex *before-cursor
+    next-cursor:address:duplex-list:character <- next *before-cursor
     break-unless next-cursor
     # scan to next character
     <move-cursor-begin>
@@ -440,7 +440,7 @@ recipe move-cursor-coordinates-right editor:address:editor-data, screen-height:n
     at-wrap?:boolean <- equal *cursor-column, wrap-column
     break-unless at-wrap?
     # and if next character isn't newline
-    next:address:duplex-list:character <- next-duplex before-cursor
+    next:address:duplex-list:character <- next before-cursor
     break-unless next
     next-character:character <- get *next, value:offset
     newline?:boolean <- equal next-character, 10/newline
@@ -674,7 +674,7 @@ after <handle-special-key> [
     break-unless move-to-previous-character?
     trace 10, [app], [left arrow]
     # if not at start of text (before-cursor at § sentinel)
-    prev:address:duplex-list:character <- prev-duplex *before-cursor
+    prev:address:duplex-list:character <- prev *before-cursor
     go-render? <- copy 0/false
     reply-unless prev
     <move-cursor-begin>
@@ -920,7 +920,7 @@ recipe move-to-previous-line editor:address:editor-data -> editor:address:editor
     {
       done?:boolean <- greater-or-equal *cursor-column, target-column
       break-if done?
-      curr:address:duplex-list:character <- next-duplex *before-cursor
+      curr:address:duplex-list:character <- next *before-cursor
       break-unless curr
       currc:character <- get *curr, value:offset
       at-newline?:boolean <- equal currc, 10/newline
@@ -1137,7 +1137,7 @@ recipe move-to-next-line editor:address:editor-data, screen-height:number -> edi
     {
       done?:boolean <- greater-or-equal *cursor-column, target-column
       break-if done?
-      curr:address:duplex-list:character <- next-duplex *before-cursor
+      curr:address:duplex-list:character <- next *before-cursor
       break-unless curr
       currc:character <- get *curr, value:offset
       at-newline?:boolean <- equal currc, 10/newline
@@ -1261,7 +1261,7 @@ recipe move-to-start-of-line editor:address:editor-data [
     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
+    *before-cursor <- prev *before-cursor
     assert *before-cursor, [move-to-start-of-line tried to move before start of text]
     loop
   }
@@ -1422,7 +1422,7 @@ recipe move-to-end-of-line editor:address:editor-data [
   cursor-column:address:number <- get-address *editor, cursor-column:offset
   # while not at start of line, move 
   {
-    next:address:duplex-list:character <- next-duplex *before-cursor
+    next:address:duplex-list:character <- next *before-cursor
     break-unless next  # end of text
     nextc:character <- get *next, value:offset
     at-end-of-line?:boolean <- equal nextc, 10/newline
@@ -1552,20 +1552,20 @@ recipe delete-to-start-of-line editor:address:editor-data -> result:address:dupl
   init:address:duplex-list:character <- get *editor, data:offset
   before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset
   start:address:duplex-list:character <- copy *before-cursor
-  end:address:duplex-list:character <- next-duplex *before-cursor
+  end:address:duplex-list:character <- next *before-cursor
   {
     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
+    start <- prev start
     assert start, [delete-to-start-of-line tried to move before start of text]
     loop
   }
   # snip it out
-  result:address:duplex-list:character <- next-duplex start
-  remove-duplex-between start, end
+  result:address:duplex-list:character <- next start
+  remove-between start, end
   # adjust cursor
   *before-cursor <- copy start
   left:number <- get *editor, left:offset
@@ -1684,19 +1684,19 @@ recipe delete-to-end-of-line editor:address:editor-data -> result:address:duplex
   load-ingredients
   # compute range to delete
   start:address:duplex-list:character <- get *editor, before-cursor:offset
-  end:address:duplex-list:character <- next-duplex start
+  end:address:duplex-list:character <- next start
   {
     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
+    end <- next end
     loop
   }
   # snip it out
-  result <- next-duplex start
-  remove-duplex-between start, end
+  result <- next start
+  remove-between start, end
 ]
 
 scenario editor-deletes-to-end-of-line-with-ctrl-k-2 [
@@ -1874,7 +1874,7 @@ recipe before-start-of-next-line original:address:duplex-list:character, max:num
     c:character <- get *curr, value:offset
     at-newline?:boolean <- equal c, 10/newline
     break-unless at-newline?
-    curr <- next-duplex curr
+    curr <- next curr
     count <- add count, 1
   }
   {
@@ -1884,7 +1884,7 @@ recipe before-start-of-next-line original:address:duplex-list:character, max:num
     c:character <- get *curr, value:offset
     at-newline?:boolean <- equal c, 10/newline
     break-if at-newline?
-    curr <- next-duplex curr
+    curr <- next curr
     count <- add count, 1
     loop
   }
@@ -2246,7 +2246,7 @@ recipe before-previous-line curr:address:duplex-list:character, editor:address:e
   {
     break-if len
     # empty line; just skip this newline
-    prev:address:duplex-list:character <- prev-duplex curr
+    prev:address:duplex-list:character <- prev curr
     reply-unless prev, curr
     reply prev
   }
@@ -2262,7 +2262,7 @@ recipe before-previous-line curr:address:duplex-list:character, editor:address:e
   {
     done?:boolean <- greater-or-equal count, max
     break-if done?
-    prev:address:duplex-list:character <- prev-duplex curr
+    prev:address:duplex-list:character <- prev curr
     break-unless prev
     curr <- copy prev
     count <- add count, 1
@@ -2648,13 +2648,13 @@ recipe page-down editor:address:editor-data -> editor:address:editor-data [
   reply-unless bottom-of-screen
   # if not, position cursor at final character
   before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset
-  *before-cursor <- prev-duplex bottom-of-screen
+  *before-cursor <- prev bottom-of-screen
   # keep one line in common with previous page
   {
     last:character <- get **before-cursor, value:offset
     newline?:boolean <- equal last, 10/newline
     break-unless newline?:boolean
-    *before-cursor <- prev-duplex *before-cursor
+    *before-cursor <- prev *before-cursor
   }
   # move cursor and top-of-screen to start of that line
   move-to-start-of-line editor
diff --git a/edit/005-sandbox.mu b/edit/005-sandbox.mu
index 358d148c..79da2409 100644
--- a/edit/005-sandbox.mu
+++ b/edit/005-sandbox.mu
@@ -151,7 +151,7 @@ recipe run-sandboxes env:address:programming-environment-data, screen:address:sc
     *dest <- copy new-sandbox
     # clear sandbox editor
     init:address:address:duplex-list:character <- get-address *current-sandbox, data:offset
-    *init <- push-duplex 167/§, 0/tail
+    *init <- push 167/§, 0/tail
     top-of-screen:address:address:duplex-list:character <- get-address *current-sandbox, top-of-screen:offset
     *top-of-screen <- copy *init
   }
@@ -474,13 +474,13 @@ recipe editor-contents editor:address:editor-data -> result:address:array:charac
   curr:address:duplex-list:character <- get *editor, data:offset
   # skip § sentinel
   assert curr, [editor without data is illegal; must have at least a sentinel]
-  curr <- next-duplex curr
+  curr <- next curr
   reply-unless curr, 0
   {
     break-unless curr
     c:character <- get *curr, value:offset
     buffer-append buf, c
-    curr <- next-duplex curr
+    curr <- next curr
     loop
   }
   result <- buffer-to-array buf
diff --git a/edit/006-sandbox-edit.mu b/edit/006-sandbox-edit.mu
index bec144f4..ea95c6af 100644
--- a/edit/006-sandbox-edit.mu
+++ b/edit/006-sandbox-edit.mu
@@ -93,7 +93,7 @@ recipe empty-editor? editor:address:editor-data -> result:boolean [
   local-scope
   load-ingredients
   head:address:duplex-list:character <- get *editor, data:offset
-  first:address:duplex-list:character <- next-duplex head
+  first:address:duplex-list:character <- next head
   result <- not first
 ]
 
diff --git a/edit/011-editor-undo.mu b/edit/011-editor-undo.mu
index 655d30fb..0e423ff4 100644
--- a/edit/011-editor-undo.mu
+++ b/edit/011-editor-undo.mu
@@ -150,7 +150,7 @@ before <insert-character-end> [
     previous-coalesce-tag:number <- get *typing, tag:offset
     break-unless previous-coalesce-tag
     insert-until:address:address:duplex-list:character <- get-address *typing, insert-until:offset
-    *insert-until <- next-duplex *before-cursor
+    *insert-until <- next *before-cursor
     after-row:address:number <- get-address *typing, after-row:offset
     *after-row <- copy *cursor-row
     after-column:address:number <- get-address *typing, after-column:offset
@@ -160,8 +160,8 @@ before <insert-character-end> [
     break +done-adding-insert-operation:label
   }
   # if not, create a new operation
-  insert-from:address:duplex-list:character <- next-duplex cursor-before
-  insert-to:address:duplex-list:character <- next-duplex insert-from
+  insert-from:address:duplex-list:character <- next cursor-before
+  insert-to:address:duplex-list:character <- next insert-from
   op:address:operation <- new operation:type
   *op <- merge 0/insert-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, insert-from, insert-to, 1/coalesce
   editor <- add-operation editor, op
@@ -178,8 +178,8 @@ after <insert-enter-begin> [
 before <insert-enter-end> [
   top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
   # never coalesce
-  insert-from:address:duplex-list:character <- next-duplex cursor-before
-  insert-to:address:duplex-list:character <- next-duplex *before-cursor
+  insert-from:address:duplex-list:character <- next cursor-before
+  insert-to:address:duplex-list:character <- next *before-cursor
   op:address:operation <- new operation:type
   *op <- merge 0/insert-operation, cursor-row-before, cursor-column-before, top-before, *cursor-row/after, *cursor-column/after, top-after, insert-from, insert-to, 0/never-coalesce
   editor <- add-operation editor, op
@@ -206,8 +206,8 @@ after <handle-undo> [
     start:address:duplex-list:character <- get *typing, insert-from:offset
     end:address:duplex-list:character <- get *typing, insert-until:offset
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
-    *before-cursor <- prev-duplex start
-    remove-duplex-between *before-cursor, end
+    *before-cursor <- prev start
+    remove-between *before-cursor, end
     *cursor-row <- get *typing, before-row:offset
     *cursor-column <- get *typing, before-column:offset
     top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset
@@ -401,8 +401,8 @@ after <handle-redo> [
     typing:address:insert-operation <- maybe-convert *op, typing:variant
     break-unless typing
     insert-from:address:duplex-list:character <- get *typing, insert-from:offset  # ignore insert-to because it's already been spliced away
-    # assert insert-to matches next-duplex(*before-cursor)
-    insert-duplex-range *before-cursor, insert-from
+    # assert insert-to matches next(*before-cursor)
+    insert-range *before-cursor, insert-from
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     *cursor-row <- get *typing, after-row:offset
     *cursor-column <- get *typing, after-column:offset
@@ -1608,7 +1608,7 @@ before <backspace-character-end> [
       delete-from:address:address:duplex-list:character <- get-address *deletion, delete-from:offset
       *delete-from <- copy *before-cursor
       backspaced-so-far:address:address:duplex-list:character <- get-address *deletion, deleted-text:offset
-      insert-duplex-range backspaced-cell, *backspaced-so-far
+      insert-range backspaced-cell, *backspaced-so-far
       *backspaced-so-far <- copy backspaced-cell
       after-row:address:number <- get-address *deletion, after-row:offset
       *after-row <- copy *cursor-row
@@ -1620,7 +1620,7 @@ before <backspace-character-end> [
     }
     # if not, create a new operation
     op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next-duplex *before-cursor
+    deleted-until:address:duplex-list:character <- next *before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, backspaced-cell/deleted, *before-cursor/delete-from, deleted-until, 1/coalesce-backspace
     editor <- add-operation editor, op
     +done-adding-backspace-operation
@@ -1635,8 +1635,8 @@ after <handle-undo> [
     anchor:address:duplex-list:character <- get *deletion, delete-from:offset
     break-unless anchor
     deleted:address:duplex-list:character <- get *deletion, deleted-text:offset
-    old-cursor:address:duplex-list:character <- last-duplex deleted
-    insert-duplex-range anchor, deleted
+    old-cursor:address:duplex-list:character <- last deleted
+    insert-range anchor, deleted
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     *before-cursor <- copy old-cursor
     *cursor-row <- get *deletion, before-row:offset
@@ -1652,7 +1652,7 @@ after <handle-redo> [
     break-unless deletion
     start:address:duplex-list:character <- get *deletion, delete-from:offset
     end:address:duplex-list:character <- get *deletion, delete-until:offset
-    remove-duplex-between start, end
+    remove-between start, end
     # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen
     *cursor-row <- get *deletion, after-row:offset
     *cursor-column <- get *deletion, after-column:offset
@@ -1828,9 +1828,9 @@ before <delete-character-end> [
       coalesce?:boolean <- equal previous-coalesce-tag, 2/coalesce-delete
       break-unless coalesce?
       delete-until:address:address:duplex-list:character <- get-address *deletion, delete-until:offset
-      *delete-until <- next-duplex *before-cursor
+      *delete-until <- next *before-cursor
       deleted-so-far:address:address:duplex-list:character <- get-address *deletion, deleted-text:offset
-      *deleted-so-far <- append-duplex *deleted-so-far, deleted-cell
+      *deleted-so-far <- append *deleted-so-far, deleted-cell
       after-row:address:number <- get-address *deletion, after-row:offset
       *after-row <- copy *cursor-row
       after-column:address:number <- get-address *deletion, after-column:offset
@@ -1841,7 +1841,7 @@ before <delete-character-end> [
     }
     # if not, create a new operation
     op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next-duplex *before-cursor
+    deleted-until:address:duplex-list:character <- next *before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cell/deleted, *before-cursor/delete-from, deleted-until, 2/coalesce-delete
     editor <- add-operation editor, op
     +done-adding-delete-operation
@@ -1942,7 +1942,7 @@ before <delete-to-end-of-line-end> [
     top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
     undo:address:address:list:address:operation <- get-address *editor, undo:offset
     op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next-duplex *before-cursor
+    deleted-until:address:duplex-list:character <- next *before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cells/deleted, *before-cursor/delete-from, deleted-until, 0/never-coalesce
     editor <- add-operation editor, op
     +done-adding-delete-operation
@@ -2043,7 +2043,7 @@ before <delete-to-start-of-line-end> [
     top-after:address:duplex-list:character <- get *editor, top-of-screen:offset
     undo:address:address:list:address:operation <- get-address *editor, undo:offset
     op:address:operation <- new operation:type
-    deleted-until:address:duplex-list:character <- next-duplex *before-cursor
+    deleted-until:address:duplex-list:character <- next *before-cursor
     *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cells/deleted, *before-cursor/delete-from, deleted-until, 0/never-coalesce
     editor <- add-operation editor, op
     +done-adding-delete-operation