about summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Readme.md24
-rw-r--r--channel.mu6
-rw-r--r--edit.mu6
-rw-r--r--factorial.mu8
-rw-r--r--generic.mu10
-rw-r--r--mu.arc124
-rw-r--r--mu.arc.t146
-rw-r--r--tangle.mu8
8 files changed, 169 insertions, 163 deletions
diff --git a/Readme.md b/Readme.md
index cc89a3d7..1ce8d44b 100644
--- a/Readme.md
+++ b/Readme.md
@@ -71,19 +71,19 @@ As a sneak peek, here's how you compute factorial in mu:
 ```lisp
   def factorial [
     ; allocate some space for local variables
-    default-scope/scope-address <- new scope/literal 30/literal
-    ; receive args from caller in a queue
-    n/integer <- arg
+    default-scope/scope-address <- new scope/literal, 30/literal
+    ; receive inputs in a queue
+    n/integer <- next-input
     {
       ; if n=0 return 1
-      zero?/boolean <- eq n/integer, 0/literal
+      zero?/boolean <- equal n/integer, 0/literal
       break-unless zero?/boolean
       reply 1/literal
     }
     ; return n*factorial(n-1)
-    tmp1/integer <- sub n/integer, 1/literal
+    tmp1/integer <- subtract n/integer, 1/literal
     tmp2/integer <- factorial tmp1/integer
-    result/integer <- mul tmp2/integer, n/integer
+    result/integer <- multiply tmp2/integer, n/integer
     reply result/integer
   ]
 ```
@@ -101,7 +101,7 @@ multiple output arguments. For example, you can perform integer division as
 follows:
 
 ```
-  quotient/integer, remainder/integer <- idiv 11/literal, 3/literal
+  quotient/integer, remainder/integer <- divide-with-remainder 11/literal, 3/literal
 ```
 
 Each arg can have any number of bits of metadata like the types above,
@@ -127,8 +127,8 @@ inserting code at them.
 
 ```lisp
   def factorial [
-    default-scope/scope-address <- new scope/literal 30/literal
-    n/integer <- arg
+    default-scope/scope-address <- new scope/literal, 30/literal
+    n/integer <- next-input
     {
       base-case
     }
@@ -137,16 +137,16 @@ inserting code at them.
 
   after base-case [
     ; if n=0 return 1
-    zero?/boolean <- eq n/integer, 0/literal
+    zero?/boolean <- equal n/integer, 0/literal
     break-unless zero?/boolean
     reply 1/literal
   ]
 
   after recursive-case [
     ; return n*factorial(n-1)
-    tmp1/integer <- sub n/integer, 1/literal
+    tmp1/integer <- subtract n/integer, 1/literal
     tmp2/integer <- factorial tmp1/integer
-    result/integer <- mul tmp2/integer, n/integer
+    result/integer <- multiply tmp2/integer, n/integer
     reply result/integer
   ]
 ```
diff --git a/channel.mu b/channel.mu
index 3cd5ea0a..5eb8849e 100644
--- a/channel.mu
+++ b/channel.mu
@@ -1,11 +1,11 @@
 (def producer [
   ; produce numbers 1 to 5 on a channel
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel-address) <- arg)
+  ((chan channel-address) <- next-input)
   ; n = 0
   ((n integer) <- copy (0 literal))
   { begin
-    ((done? boolean) <- lt (n integer) (5 literal))
+    ((done? boolean) <- less-than (n integer) (5 literal))
     (break-unless (done? boolean))
     ; other threads might get between these prints
     (print-primitive ("produce: " literal))
@@ -25,7 +25,7 @@
 (def consumer [
   ; consume and print integers from a channel
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel-address) <- arg)
+  ((chan channel-address) <- next-input)
   { begin
     ; read a tagged value from the channel
     ((x tagged-value) (chan channel-address deref) <- read (chan channel-address))
diff --git a/edit.mu b/edit.mu
index 47071c57..2f4ff6bf 100644
--- a/edit.mu
+++ b/edit.mu
@@ -2,8 +2,8 @@
 
 (def new-screen [
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((nrows integer) <- arg)
-  ((ncols integer) <- arg)
+  ((nrows integer) <- next-input)
+  ((ncols integer) <- next-input)
   ((result screen-address) <- new (screen literal) (nrows integer))
   ((rowidx integer) <- copy (0 literal))
   { begin
@@ -11,7 +11,7 @@
     ((curr-line-address-address line-address-address deref) <- new (line literal) (ncols integer))
     ((curr-line-address line-address) <- copy (curr-line-address-address line-address-address deref))
     ((rowidx integer) <- add (rowidx integer) (1 literal))
-    ((x boolean) <- neq (rowidx integer) (nrows integer))
+    ((x boolean) <- not-equal (rowidx integer) (nrows integer))
     (loop-if (x boolean))
   }
   (reply (result screen-address))
diff --git a/factorial.mu b/factorial.mu
index 9a07bc07..d94a9354 100644
--- a/factorial.mu
+++ b/factorial.mu
@@ -1,16 +1,16 @@
 (def factorial [
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((n integer) <- arg)
+  ((n integer) <- next-input)
   { begin
     ; if n=0 return 1
-    ((zero? boolean) <- eq (n integer) (0 literal))
+    ((zero? boolean) <- equal (n integer) (0 literal))
     (break-unless (zero? boolean))
     (reply (1 literal))
   }
   ; return n*factorial(n-1)
-  ((x integer) <- sub (n integer) (1 literal))
+  ((x integer) <- subtract (n integer) (1 literal))
   ((subresult integer) <- factorial (x integer))
-  ((result integer) <- mul (subresult integer) (n integer))
+  ((result integer) <- multiply (subresult integer) (n integer))
   (reply (result integer))
 ])
 
diff --git a/generic.mu b/generic.mu
index e73612c5..8b65d109 100644
--- a/generic.mu
+++ b/generic.mu
@@ -1,21 +1,21 @@
 ; To demonstrate generic functions, we'll construct a factorial function with
-; separate base and recursive cases. Compare factorial.mu.
+; separate base and recursive clauses. Compare factorial.mu.
 
 ; def factorial n = n*factorial(n-1)
 (def factorial [
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((n integer) <- arg (0 literal))
+  ((n integer) <- input (0 literal))
   more-clauses
-  ((x integer) <- sub (n integer) (1 literal))
+  ((x integer) <- subtract (n integer) (1 literal))
   ((subresult integer) <- factorial (x integer))
-  ((result integer) <- mul (subresult integer) (n integer))
+  ((result integer) <- multiply (subresult integer) (n integer))
   (reply (result integer))
 ])
 
 ; def factorial 0 = 1
 (after factorial/more-clauses [
   { begin
-    ((zero? boolean) <- eq (n integer) (0 literal))
+    ((zero? boolean) <- equal (n integer) (0 literal))
     (break-unless (zero? boolean))
     (reply (1 literal))
   }
diff --git a/mu.arc b/mu.arc
index a8d86091..8f59a317 100644
--- a/mu.arc
+++ b/mu.arc
@@ -345,13 +345,13 @@
                   (do (trace "add" (m arg.0) " " (m arg.1))
                   (+ (m arg.0) (m arg.1))
                   )
-                sub
+                subtract
                   (- (m arg.0) (m arg.1))
-                mul
+                multiply
                   (* (m arg.0) (m arg.1))
-                div
+                divide
                   (/ (real (m arg.0)) (m arg.1))
-                idiv
+                divide-with-remainder
                   (list (trunc:/ (m arg.0) (m arg.1))
                         (mod (m arg.0) (m arg.1)))
 
@@ -364,19 +364,19 @@
                   (not (m arg.0))
 
                 ; comparison
-                eq
+                equal
                   (is (m arg.0) (m arg.1))
-                neq
+                not-equal
                   (do (trace "neq" (m arg.0) " " (m arg.1))
                   (~is (m arg.0) (m arg.1))
                   )
-                lt
+                less-than
                   (< (m arg.0) (m arg.1))
-                gt
+                greater-than
                   (> (m arg.0) (m arg.1))
-                le
+                lesser-or-equal
                   (<= (m arg.0) (m arg.1))
-                ge
+                greater-or-equal
                   (>= (m arg.0) (m arg.1))
 
                 ; control flow
@@ -451,7 +451,7 @@
                         (new-scalar type))))
                 sizeof
                   (sizeof (m arg.0))
-                len
+                length
                   (let base arg.0
                     (if (or typeinfo.base!array typeinfo.base!address)
                       array-len.base
@@ -488,15 +488,15 @@
                     ((abort-routine*)))
 
                 ; text interaction
-                cls
+                clear-screen
                   (do1 nil ($.charterm-clear-screen))
-                cll
+                clear-line
                   (do1 nil ($.charterm-clear-line))
                 cursor
                   (do1 nil ($.charterm-cursor (m arg.0) (m arg.1)))
                 print-primitive
                   (do1 nil ((if ($.current-charterm) $.charterm-display pr) (m arg.0)))
-                getc
+                read-key
                   (and ($.charterm-byte-ready?) ($.charterm-read-key))
                 bold-mode
                   (do1 nil ($.charterm-bold))
@@ -508,10 +508,16 @@
                   (do1 nil (if ($.current-charterm) ($.close-charterm)))
 
                 ; user-defined functions
-                arg
-                  (do (when arg
-                        (assert (is 'literal (ty arg.0)))
-                        (= caller-arg-idx.routine* (v arg.0)))
+                next-input
+                  (let idx caller-arg-idx.routine*
+                    (++ caller-arg-idx.routine*)
+                    (trace "arg" arg " " idx " " caller-args.routine*)
+                    (if (len> caller-args.routine* idx)
+                      (list caller-args.routine*.idx t)
+                      (list nil nil)))
+                input
+                  (do (assert (is 'literal (ty arg.0)))
+                      (= caller-arg-idx.routine* (v arg.0))
                       (let idx caller-arg-idx.routine*
                         (++ caller-arg-idx.routine*)
                         (trace "arg" arg " " idx " " caller-args.routine*)
@@ -979,10 +985,10 @@
 (init-fn maybe-coerce
   ((default-scope scope-address) <- new (scope literal) (30 literal))
   ((x tagged-value-address) <- new (tagged-value literal))
-  ((x tagged-value-address deref) <- arg)
-  ((p type) <- arg)
+  ((x tagged-value-address deref) <- next-input)
+  ((p type) <- next-input)
   ((xtype type) <- get (x tagged-value-address deref) (0 offset))
-  ((match? boolean) <- eq (xtype type) (p type))
+  ((match? boolean) <- equal (xtype type) (p type))
   { begin
     (break-if (match? boolean))
     (reply (0 literal) (nil literal))
@@ -993,9 +999,9 @@
 (init-fn new-tagged-value
   ((default-scope scope-address) <- new (scope literal) (30 literal))
   ; assert (sizeof arg.0) == 1
-  ((xtype type) <- arg)
+  ((xtype type) <- next-input)
   ((xtypesize integer) <- sizeof (xtype type))
-  ((xcheck boolean) <- eq (xtypesize integer) (1 literal))
+  ((xcheck boolean) <- equal (xtypesize integer) (1 literal))
   (assert (xcheck boolean))
   ; todo: check that arg 0 matches the type? or is that for the future typechecker?
   ((result tagged-value-address) <- new (tagged-value literal))
@@ -1004,18 +1010,18 @@
   ((resulttype location deref) <- copy (xtype type))
   ; result->payload = arg 1
   ((locaddr location) <- get-address (result tagged-value-address deref) (payload offset))
-  ((locaddr location deref) <- arg)
+  ((locaddr location deref) <- next-input)
   (reply (result tagged-value-address)))
 
 (init-fn list-next  ; list-address -> list-address
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((base list-address) <- arg)
+  ((base list-address) <- next-input)
   ((result list-address) <- get (base list-address deref) (cdr offset))
   (reply (result list-address)))
 
 (init-fn list-value-address  ; list-address -> tagged-value-address
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((base list-address) <- arg)
+  ((base list-address) <- next-input)
   ((result tagged-value-address) <- get-address (base list-address deref) (car offset))
   (reply (result tagged-value-address)))
 
@@ -1026,7 +1032,7 @@
   ((curr list-address) <- copy (new-list-result list-address))
   { begin
     ; while read curr-value
-    ((curr-value integer) (exists? boolean) <- arg)
+    ((curr-value integer) (exists? boolean) <- next-input)
     (break-unless (exists? boolean))
     ; curr.cdr = new list
     ((next list-address-address) <- get-address (curr list-address deref) (cdr offset))
@@ -1053,7 +1059,7 @@
   ((free integer-address) <- get-address (result channel-address deref) (first-free offset))
   ((free integer-address deref) <- copy (0 literal))
   ; result.circular-buffer = new tagged-value[arg+1]
-  ((capacity integer) <- arg)
+  ((capacity integer) <- next-input)
   ((capacity integer) <- add (capacity integer) (1 literal))  ; unused slot for full? below
   ((channel-buffer-address tagged-value-array-address-address) <- get-address (result channel-address deref) (circular-buffer offset))
   ((channel-buffer-address tagged-value-array-address-address deref) <- new (tagged-value-array literal) (capacity integer))
@@ -1061,15 +1067,15 @@
 
 (init-fn capacity
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel) <- arg)
+  ((chan channel) <- next-input)
   ((q tagged-value-array-address) <- get (chan channel) (circular-buffer offset))
-  ((qlen integer) <- len (q tagged-value-array-address deref))
+  ((qlen integer) <- length (q tagged-value-array-address deref))
   (reply (qlen integer)))
 
 (init-fn write
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel-address) <- arg)
-  ((val tagged-value) <- arg)
+  ((chan channel-address) <- next-input)
+  ((val tagged-value) <- next-input)
   { begin
     ; block if chan is full
     ((full boolean) <- full? (chan channel-address deref))
@@ -1086,8 +1092,8 @@
   ((free integer-address deref) <- add (free integer-address deref) (1 literal))
   { begin
     ; wrap free around to 0 if necessary
-    ((qlen integer) <- len (q tagged-value-array-address deref))
-    ((remaining? boolean) <- lt (free integer-address deref) (qlen integer))
+    ((qlen integer) <- length (q tagged-value-array-address deref))
+    ((remaining? boolean) <- less-than (free integer-address deref) (qlen integer))
     (break-if (remaining? boolean))
     ((free integer-address deref) <- copy (0 literal))
   }
@@ -1095,7 +1101,7 @@
 
 (init-fn read
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel-address) <- arg)
+  ((chan channel-address) <- next-input)
   { begin
     ; block if chan is empty
     ((empty boolean) <- empty? (chan channel-address deref))
@@ -1111,8 +1117,8 @@
   ((full integer-address deref) <- add (full integer-address deref) (1 literal))
   { begin
     ; wrap full around to 0 if necessary
-    ((qlen integer) <- len (q tagged-value-array-address deref))
-    ((remaining? boolean) <- lt (full integer-address deref) (qlen integer))
+    ((qlen integer) <- length (q tagged-value-array-address deref))
+    ((remaining? boolean) <- less-than (full integer-address deref) (qlen integer))
     (break-if (remaining? boolean))
     ((full integer-address deref) <- copy (0 literal))
   }
@@ -1122,39 +1128,39 @@
 (init-fn empty?
   ((default-scope scope-address) <- new (scope literal) (30 literal))
   ; return arg.first-full == arg.first-free
-  ((chan channel) <- arg)
+  ((chan channel) <- next-input)
   ((full integer) <- get (chan channel) (first-full offset))
   ((free integer) <- get (chan channel) (first-free offset))
-  ((result boolean) <- eq (full integer) (free integer))
+  ((result boolean) <- equal (full integer) (free integer))
   (reply (result boolean)))
 
 ; A full channel has first-empty just before first-full, wasting one slot.
 ; (Other alternatives: https://en.wikipedia.org/wiki/Circular_buffer#Full_.2F_Empty_Buffer_Distinction)
 (init-fn full?
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((chan channel) <- arg)
+  ((chan channel) <- next-input)
   ; curr = chan.first-free + 1
   ((curr integer) <- get (chan channel) (first-free offset))
   ((curr integer) <- add (curr integer) (1 literal))
   { begin
     ; if (curr == chan.capacity) curr = 0
     ((qlen integer) <- capacity (chan channel))
-    ((remaining? boolean) <- lt (curr integer) (qlen integer))
+    ((remaining? boolean) <- less-than (curr integer) (qlen integer))
     (break-if (remaining? boolean))
     ((curr integer) <- copy (0 literal))
   }
   ; return chan.first-full == curr
   ((full integer) <- get (chan channel) (first-full offset))
-  ((result boolean) <- eq (full integer) (curr integer))
+  ((result boolean) <- equal (full integer) (curr integer))
   (reply (result boolean)))
 
 (init-fn strcat
   ((default-scope scope-address) <- new (scope literal) (30 literal))
   ; result = new string[a.length + b.length]
-  ((a string-address) <- arg)
-  ((a-len integer) <- len (a string-address deref))
-  ((b string-address) <- arg)
-  ((b-len integer) <- len (b string-address deref))
+  ((a string-address) <- next-input)
+  ((a-len integer) <- length (a string-address deref))
+  ((b string-address) <- next-input)
+  ((b-len integer) <- length (b string-address deref))
   ((result-len integer) <- add (a-len integer) (b-len integer))
   ((result string-address) <- new (string literal) (result-len integer))
   ; copy a into result
@@ -1162,7 +1168,7 @@
   ((i integer) <- copy (0 literal))
   { begin
     ; while (i < a.length)
-    ((a-done? boolean) <- lt (i integer) (a-len integer))
+    ((a-done? boolean) <- less-than (i integer) (a-len integer))
     (break-unless (a-done? boolean))
     ; result[result-idx] = a[i]
     ((out byte-address) <- index-address (result string-address deref) (result-idx integer))
@@ -1178,7 +1184,7 @@
   ((i integer) <- copy (0 literal))
   { begin
     ; while (i < b.length)
-    ((b-done? boolean) <- lt (i integer) (b-len integer))
+    ((b-done? boolean) <- less-than (i integer) (b-len integer))
     (break-unless (b-done? boolean))
     ; result[result-idx] = a[i]
     ((out byte-address) <- index-address (result string-address deref) (result-idx integer))
@@ -1195,13 +1201,13 @@
 ; replace underscores in first with remaining args
 (init-fn interpolate  ; string-address template, string-address a..
   ((default-scope scope-address) <- new (scope literal) (60 literal))
-  ((template string-address) <- arg)
+  ((template string-address) <- next-input)
   ; compute result-len, space to allocate for result
-  ((tem-len integer) <- len (template string-address deref))
+  ((tem-len integer) <- length (template string-address deref))
   ((result-len integer) <- copy (tem-len integer))
   { begin
     ; while arg received
-    ((a string-address) (arg-received? boolean) <- arg)
+    ((a string-address) (arg-received? boolean) <- next-input)
     (break-unless (arg-received? boolean))
 ;?     (print-primitive ("arg now: " literal))
 ;?     (print-primitive (a string-address))
@@ -1210,16 +1216,16 @@
 ;?     (print-primitive ("\n" literal))
 ;? ;?     (assert (nil literal))
     ; result-len = result-len + arg.length - 1 (for the 'underscore' being replaced)
-    ((a-len integer) <- len (a string-address deref))
+    ((a-len integer) <- length (a string-address deref))
     ((result-len integer) <- add (result-len integer) (a-len integer))
-    ((result-len integer) <- sub (result-len integer) (1 literal))
+    ((result-len integer) <- subtract (result-len integer) (1 literal))
 ;?     (print-primitive ("result-len now: " literal))
 ;?     (print-primitive (result-len integer))
 ;?     (print-primitive ("\n" literal))
     (loop)
   }
   ; rewind to start of non-template args
-  (_ <- arg (0 literal))
+  (_ <- input (0 literal))
   ; result = new string[result-len]
   ((result string-address) <- new (string literal) (result-len integer))
   ; repeatedly copy sections of template and 'holes' into result
@@ -1227,16 +1233,16 @@
   ((i integer) <- copy (0 literal))
   { begin
     ; while arg received
-    ((a string-address) (arg-received? boolean) <- arg)
+    ((a string-address) (arg-received? boolean) <- next-input)
     (break-unless (arg-received? boolean))
     ; copy template into result until '_'
     { begin
       ; while (i < template.length)
-      ((tem-done? boolean) <- lt (i integer) (tem-len integer))
+      ((tem-done? boolean) <- less-than (i integer) (tem-len integer))
       (break-unless (tem-done? boolean) (2 blocks))
       ; while template[i] != '_'
       ((in byte) <- index (template string-address deref) (i integer))
-      ((underscore? boolean) <- eq (in byte) (#\_ literal))
+      ((underscore? boolean) <- equal (in byte) (#\_ literal))
       (break-if (underscore? boolean))
       ; result[result-idx] = template[i]
       ((out byte-address) <- index-address (result string-address deref) (result-idx integer))
@@ -1254,7 +1260,7 @@
     ((j integer) <- copy (0 literal))
     { begin
       ; while (j < a.length)
-      ((arg-done? boolean) <- lt (j integer) (a-len integer))
+      ((arg-done? boolean) <- less-than (j integer) (a-len integer))
       (break-unless (arg-done? boolean))
       ; result[result-idx] = a[j]
       ((in byte) <- index (a string-address deref) (j integer))
@@ -1281,7 +1287,7 @@
   ; done with holes; copy rest of template directly into result
   { begin
     ; while (i < template.length)
-    ((tem-done? boolean) <- lt (i integer) (tem-len integer))
+    ((tem-done? boolean) <- less-than (i integer) (tem-len integer))
     (break-unless (tem-done? boolean))
     ; result[result-idx] = template[i]
     ((in byte) <- index (template string-address deref) (i integer))
diff --git a/mu.arc.t b/mu.arc.t
index 38702b69..be7eb9ce 100644
--- a/mu.arc.t
+++ b/mu.arc.t
@@ -190,52 +190,52 @@
 (new-trace "sub-literal")
 (add-code
   '((def main [
-      ((1 integer) <- sub (1 literal) (3 literal))
+      ((1 integer) <- subtract (1 literal) (3 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 -2)
-  (prn "F - 'sub' subtracts the second arg from the first"))
+  (prn "F - 'subtract'"))
 
 (reset)
 (new-trace "mul-literal")
 (add-code
   '((def main [
-      ((1 integer) <- mul (2 literal) (3 literal))
+      ((1 integer) <- multiply (2 literal) (3 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 6)
-  (prn "F - 'mul' multiplies like 'add' adds"))
+  (prn "F - 'multiply'"))
 
 (reset)
 (new-trace "div-literal")
 (add-code
   '((def main [
-      ((1 integer) <- div (8 literal) (3 literal))
+      ((1 integer) <- divide (8 literal) (3 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 (/ real.8 3))
-  (prn "F - 'div' divides like 'sub' subtracts"))
+  (prn "F - 'divide'"))
 
 (reset)
 (new-trace "idiv-literal")
 (add-code
   '((def main [
-      ((1 integer) (2 integer) <- idiv (23 literal) (6 literal))
+      ((1 integer) (2 integer) <- divide-with-remainder (23 literal) (6 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 3  2 5))
-  (prn "F - 'idiv' performs integer division, returning quotient and remainder"))
+  (prn "F - 'divide-with-remainder' performs integer division"))
 
 (reset)
 (new-trace "dummy-oarg")
 ;? (set dump-trace*)
 (add-code
   '((def main [
-      (_ (2 integer) <- idiv (23 literal) (6 literal))
+      (_ (2 integer) <- divide-with-remainder (23 literal) (6 literal))
      ])))
 (run 'main)
 (if (~iso memory* (obj 2 5))
@@ -257,51 +257,51 @@
 (if (~is memory*.1 nil)
   (prn "F - logical 'and' for booleans"))
 
-; Basic comparison operations: lt, le, gt, ge, eq, neq
+; Basic comparison operations
 
 (reset)
 (new-trace "lt-literal")
 (add-code
   '((def main [
-      ((1 boolean) <- lt (4 literal) (3 literal))
+      ((1 boolean) <- less-than (4 literal) (3 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 nil)
-  (prn "F - 'lt' is the less-than inequality operator"))
+  (prn "F - 'less-than' inequality operator"))
 
 (reset)
 (new-trace "le-literal-false")
 (add-code
   '((def main [
-      ((1 boolean) <- le (4 literal) (3 literal))
+      ((1 boolean) <- lesser-or-equal (4 literal) (3 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 nil)
-  (prn "F - 'le' is the <= inequality operator"))
+  (prn "F - 'lesser-or-equal'"))
 
 (reset)
 (new-trace "le-literal-true")
 (add-code
   '((def main [
-      ((1 boolean) <- le (4 literal) (4 literal))
+      ((1 boolean) <- lesser-or-equal (4 literal) (4 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 t)
-  (prn "F - 'le' returns true for equal operands"))
+  (prn "F - 'lesser-or-equal' returns true for equal operands"))
 
 (reset)
 (new-trace "le-literal-true-2")
 (add-code
   '((def main [
-      ((1 boolean) <- le (4 literal) (5 literal))
+      ((1 boolean) <- lesser-or-equal (4 literal) (5 literal))
      ])))
 (run 'main)
 ;? (prn memory*)
 (if (~is memory*.1 t)
-  (prn "F - le is the <= inequality operator - 2"))
+  (prn "F - 'lesser-or-equal' - 2"))
 
 ; Control flow operations: jump, jump-if, jump-unless
 ; These introduce a new type -- 'offset' -- for literals that refer to memory
@@ -342,7 +342,7 @@
 (add-code
   '((def main [
       ((2 integer) <- copy (1 literal))
-      ((1 boolean) <- eq (1 literal) (2 integer))
+      ((1 boolean) <- equal (1 literal) (2 integer))
       (jump-if (1 boolean) (1 offset))
       ((2 integer) <- copy (3 literal))
       (reply)
@@ -357,7 +357,7 @@
 (new-trace "jump-if-fallthrough")
 (add-code
   '((def main [
-      ((1 boolean) <- eq (1 literal) (2 literal))
+      ((1 boolean) <- equal (1 literal) (2 literal))
       (jump-if (3 boolean) (1 offset))
       ((2 integer) <- copy (3 literal))
       (reply)
@@ -376,7 +376,7 @@
       ((2 integer) <- copy (1 literal))
       ; loop
       ((2 integer) <- add (2 integer) (2 integer))
-      ((3 boolean) <- eq (1 integer) (2 integer))
+      ((3 boolean) <- equal (1 integer) (2 integer))
       (jump-if (3 boolean) (-3 offset))  ; to loop
       ((4 integer) <- copy (3 literal))
       (reply)
@@ -395,7 +395,7 @@
       ((2 integer) <- copy (1 literal))
       loop
       ((2 integer) <- add (2 integer) (2 integer))
-      ((3 boolean) <- eq (1 integer) (2 integer))
+      ((3 boolean) <- equal (1 integer) (2 integer))
       (jump-if (3 boolean) (loop offset))
       ((4 integer) <- copy (3 literal))
       (reply)
@@ -701,12 +701,12 @@
       ((3 boolean) <- copy (nil literal))
       ((4 integer) <- copy (24 literal))
       ((5 boolean) <- copy (t literal))
-      ((6 integer) <- len (1 integer-boolean-pair-array))
+      ((6 integer) <- length (1 integer-boolean-pair-array))
      ])))
 (run 'main)
 ;? (prn memory*)
-(if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 2))
-  (prn "F - 'len' accesses length of array"))
+(if (~is memory*.6 2)
+  (prn "F - 'length' of array"))
 
 (reset)
 (new-trace "len-array-indirect")
@@ -718,14 +718,14 @@
       ((4 integer) <- copy (24 literal))
       ((5 boolean) <- copy (t literal))
       ((6 integer-address) <- copy (1 literal))
-      ((7 integer) <- len (6 integer-boolean-pair-array-address deref))
+      ((7 integer) <- length (6 integer-boolean-pair-array-address deref))
      ])))
 ;? (set dump-trace*)
 ;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))
 (run 'main)
 ;? (prn memory*)
-(if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 1  7 2))
-  (prn "F - 'len' accesses length of array address"))
+(if (~is memory*.7 2)
+  (prn "F - 'length' of array address"))
 
 ; 'sizeof' is a helper to determine the amount of memory required by a type.
 ; Only for non-arrays.
@@ -1043,8 +1043,8 @@
 (new-trace "new-fn-arg-sequential")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) <- next-input)
       ((3 integer) <- add (4 integer) (5 integer))
       (reply)
       ((4 integer) <- copy (34 literal))
@@ -1067,8 +1067,8 @@
 ;? (set dump-trace*)
 (add-code
   '((def test1 [
-      ((5 integer) <- arg (1 literal))
-      ((4 integer) <- arg (0 literal))
+      ((5 integer) <- input (1 literal))
+      ((4 integer) <- input (0 literal))
       ((3 integer) <- add (4 integer) (5 integer))
       (reply)
       ((4 integer) <- copy (34 literal))  ; should never run
@@ -1091,8 +1091,8 @@
 ;? (set dump-trace*)
 (add-code
   '((def test1 [
-      (_ <- arg (1 literal))
-      ((1 integer) <- arg)  ; takes next arg after index 1
+      (_ <- input (1 literal))
+      ((1 integer) <- next-input)  ; takes next arg after index 1
      ])  ; should never run
     (def main [
       (test1 (1 literal) (2 literal) (3 literal))
@@ -1107,7 +1107,7 @@
 (new-trace "new-fn-arg-status")
 (add-code
   '((def test1 [
-      ((4 integer) (5 boolean) <- arg)
+      ((4 integer) (5 boolean) <- next-input)
      ])
     (def main [
       (test1 (1 literal))
@@ -1122,8 +1122,8 @@
 (new-trace "new-fn-arg-missing")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) <- next-input)
      ])
     (def main [
       (test1 (1 literal))
@@ -1138,8 +1138,8 @@
 (new-trace "new-fn-arg-missing-2")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) (6 boolean) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) (6 boolean) <- next-input)
      ])
     (def main [
       (test1 (1 literal))
@@ -1154,9 +1154,9 @@
 (new-trace "new-fn-arg-missing-3")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
+      ((4 integer) <- next-input)
       ((5 integer) <- copy (34 literal))
-      ((5 integer) (6 boolean) <- arg)
+      ((5 integer) (6 boolean) <- next-input)
     ])
     (def main [
       (test1 (1 literal))
@@ -1172,8 +1172,8 @@
 (add-code
   '((def test1 [
       ; if given two args, adds them; if given one arg, increments
-      ((4 integer) <- arg)
-      ((5 integer) (6 boolean) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) (6 boolean) <- next-input)
       { begin
         (break-if (6 boolean))
         ((5 integer) <- copy (1 literal))
@@ -1194,7 +1194,7 @@
 (add-code
   '((def test1 [
       ((1 integer) <- copy (0 literal))  ; overwrite caller memory
-      ((2 integer) <- arg)
+      ((2 integer) <- next-input)
      ])  ; arg not clobbered
     (def main [
       ((1 integer) <- copy (34 literal))
@@ -1209,7 +1209,7 @@
 (new-trace "arg-record")
 (add-code
   '((def test1 [
-      ((4 integer-boolean-pair) <- arg)
+      ((4 integer-boolean-pair) <- next-input)
      ])
     (def main [
       ((1 integer) <- copy (34 literal))
@@ -1225,7 +1225,7 @@
 ;? (set dump-trace*)
 (add-code
   '((def test1 [
-      ((4 integer-boolean-pair) <- arg)
+      ((4 integer-boolean-pair) <- next-input)
      ])
     (def main [
       ((1 integer) <- copy (34 literal))
@@ -1242,8 +1242,8 @@
 (new-trace "new-fn-reply-oarg")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) <- next-input)
       ((6 integer) <- add (4 integer) (5 integer))
       (reply (6 integer))
       ((4 integer) <- copy (34 literal))
@@ -1264,8 +1264,8 @@
 (new-trace "new-fn-reply-oarg-multiple")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) <- next-input)
       ((6 integer) <- add (4 integer) (5 integer))
       (reply (6 integer) (5 integer))
       ((4 integer) <- copy (34 literal))
@@ -1286,8 +1286,8 @@
 (new-trace "new-fn-prepare-reply")
 (add-code
   '((def test1 [
-      ((4 integer) <- arg)
-      ((5 integer) <- arg)
+      ((4 integer) <- next-input)
+      ((5 integer) <- next-input)
       ((6 integer) <- add (4 integer) (5 integer))
       (prepare-reply (6 integer) (5 integer))
       (reply)
@@ -1339,7 +1339,7 @@
               ((2 integer) <- copy (2 literal))
               ((3 integer) <- add (2 integer) (2 integer))
               { begin  ; 'begin' is just a hack because racket turns braces into parens
-                ((4 boolean) <- neq (1 integer) (3 integer))
+                ((4 boolean) <- not-equal (1 integer) (3 integer))
                 (break-if (4 boolean))
                 ((5 integer) <- copy (34 literal))
               }
@@ -1347,7 +1347,7 @@
           '(((1 integer) <- copy (4 literal))
             ((2 integer) <- copy (2 literal))
             ((3 integer) <- add (2 integer) (2 integer))
-            ((4 boolean) <- neq (1 integer) (3 integer))
+            ((4 boolean) <- not-equal (1 integer) (3 integer))
             (jump-if (4 boolean) (1 offset))
             ((5 integer) <- copy (34 literal))
             (reply)))
@@ -1382,7 +1382,7 @@
               ((2 integer) <- copy (2 literal))
               ((3 integer) <- add (2 integer) (2 integer))
               { begin
-                ((4 boolean) <- neq (1 integer) (3 integer))
+                ((4 boolean) <- not-equal (1 integer) (3 integer))
                 (break-if (4 boolean))
                 { begin
                   ((5 integer) <- copy (34 literal))
@@ -1392,7 +1392,7 @@
           '(((1 integer) <- copy (4 literal))
             ((2 integer) <- copy (2 literal))
             ((3 integer) <- add (2 integer) (2 integer))
-            ((4 boolean) <- neq (1 integer) (3 integer))
+            ((4 boolean) <- not-equal (1 integer) (3 integer))
             (jump-if (4 boolean) (1 offset))
             ((5 integer) <- copy (34 literal))
             (reply)))
@@ -1431,7 +1431,7 @@
               { begin
                 ((3 integer) <- add (2 integer) (2 integer))
                 { begin
-                  ((4 boolean) <- neq (1 integer) (3 integer))
+                  ((4 boolean) <- not-equal (1 integer) (3 integer))
                 }
                 (loop-if (4 boolean))
                 ((5 integer) <- copy (34 literal))
@@ -1440,7 +1440,7 @@
           '(((1 integer) <- copy (4 literal))
             ((2 integer) <- copy (2 literal))
             ((3 integer) <- add (2 integer) (2 integer))
-            ((4 boolean) <- neq (1 integer) (3 integer))
+            ((4 boolean) <- not-equal (1 integer) (3 integer))
             (jump-if (4 boolean) (-3 offset))
             ((5 integer) <- copy (34 literal))
             (reply)))
@@ -1535,7 +1535,7 @@
       ((2 integer) <- copy (1 literal))
       { begin
         ((2 integer) <- add (2 integer) (2 integer))
-        ((3 boolean) <- neq (1 integer) (2 integer))
+        ((3 boolean) <- not-equal (1 integer) (2 integer))
         (loop-if (3 boolean))
         ((4 integer) <- copy (34 literal))
       }
@@ -1561,7 +1561,7 @@
       { begin
         ((2 integer) <- add (2 integer) (2 integer))
         { begin
-          ((3 boolean) <- neq (1 integer) (2 integer))
+          ((3 boolean) <- not-equal (1 integer) (2 integer))
         }
         (loop-if (3 boolean))
         ((4 integer) <- copy (34 literal))
@@ -1584,7 +1584,7 @@
       { begin
         ((2 integer) <- add (2 integer) (2 integer))
         { begin
-          ((3 boolean) <- neq (1 integer) (2 integer))
+          ((3 boolean) <- not-equal (1 integer) (2 integer))
         }
         (loop-if (3 boolean))
         ((4 integer) <- copy (34 literal))
@@ -1958,7 +1958,7 @@
       ((4 integer) <- copy (24 literal))
       ((5 boolean) <- copy (t literal))
       ((6 integer-address) <- copy (11 literal))  ; unsafe
-      ((7 integer) <- len (6 integer-boolean-pair-array-address deref))
+      ((7 integer) <- length (6 integer-boolean-pair-array-address deref))
      ])))
 ;? (= dump-trace* (obj whitelist '("run" "addr" "sz" "array-len")))
 (run 'main)
@@ -1981,12 +1981,12 @@
       ; if it's slightly too many -- memory is plentiful
       ; if it's too few -- mu will raise an error
       ((default-scope scope-address) <- new (scope literal) (20 literal))
-      ((first-arg-box tagged-value-address) <- arg)
+      ((first-arg-box tagged-value-address) <- next-input)
       ; if given integers, add them
       { begin
         ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal))
         (break-unless (match? boolean))
-        ((second-arg-box tagged-value-address) <- arg)
+        ((second-arg-box tagged-value-address) <- next-input)
         ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal))
         ((result integer) <- add (first-arg integer) (second-arg integer))
         (reply (result integer))
@@ -2012,12 +2012,12 @@
 (add-code
   '((def test1 [
       ((default-scope scope-address) <- new (scope literal) (20 literal))
-      ((first-arg-box tagged-value-address) <- arg)
+      ((first-arg-box tagged-value-address) <- next-input)
       ; if given integers, add them
       { begin
         ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal))
         (break-unless (match? boolean))
-        ((second-arg-box tagged-value-address) <- arg)
+        ((second-arg-box tagged-value-address) <- next-input)
         ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal))
         ((result integer) <- add (first-arg integer) (second-arg integer))
         (reply (result integer))
@@ -2026,7 +2026,7 @@
       { begin
         ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal))
         (break-unless (match? boolean))
-        ((second-arg-box tagged-value-address) <- arg)
+        ((second-arg-box tagged-value-address) <- next-input)
         ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal))
         ((result boolean) <- or (first-arg boolean) (second-arg boolean))
         (reply (result integer))
@@ -2052,12 +2052,12 @@
 (add-code
   '((def test1 [
       ((default-scope scope-address) <- new (scope literal) (20 literal))
-      ((first-arg-box tagged-value-address) <- arg)
+      ((first-arg-box tagged-value-address) <- next-input)
       ; if given integers, add them
       { begin
         ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal))
         (break-unless (match? boolean))
-        ((second-arg-box tagged-value-address) <- arg)
+        ((second-arg-box tagged-value-address) <- next-input)
         ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal))
         ((result integer) <- add (first-arg integer) (second-arg integer))
         (reply (result integer))
@@ -2066,7 +2066,7 @@
       { begin
         ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal))
         (break-unless (match? boolean))
-        ((second-arg-box tagged-value-address) <- arg)
+        ((second-arg-box tagged-value-address) <- next-input)
         ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal))
         ((result boolean) <- or (first-arg boolean) (second-arg boolean))
         (reply (result integer))
@@ -2424,7 +2424,7 @@
       (fork (f2 fn) (4 literal))
      ])
     (def f2 [
-      ((2 integer) <- arg)
+      ((2 integer) <- next-input)
      ])))
 (run 'f1)
 (if (~iso memory*.2 4)
@@ -2440,7 +2440,7 @@
       ((x integer) <- copy (0 literal))  ; should be ignored
      ])
     (def f2 [
-      ((2 integer) <- arg)
+      ((2 integer) <- next-input)
      ])))
 (run 'f1)
 (if (~iso memory*.2 4)
@@ -2763,7 +2763,7 @@
       ((default-scope scope-address) <- new (scope literal) (30 literal))
       ((n integer-address) <- new (integer literal))
       ((n integer-address deref) <- copy (24 literal))
-      ((ochan channel-address) <- arg)
+      ((ochan channel-address) <- next-input)
       ((x tagged-value) <- save-type (n integer-address))
       ((ochan channel-address deref) <- write (ochan channel-address) (x tagged-value))
      ])))
diff --git a/tangle.mu b/tangle.mu
index 46ddd6fc..21d9800e 100644
--- a/tangle.mu
+++ b/tangle.mu
@@ -5,7 +5,7 @@
 
 (def factorial [
   ((default-scope scope-address) <- new (scope literal) (30 literal))
-  ((n integer) <- arg)
+  ((n integer) <- next-input)
   { begin
     base-case
   }
@@ -14,16 +14,16 @@
 
 (after base-case [
   ; if n=0 return 1
-  ((zero? boolean) <- eq (n integer) (0 literal))
+  ((zero? boolean) <- equal (n integer) (0 literal))
   (break-unless (zero? boolean))
   (reply (1 literal))
 ])
 
 (after recursive-case [
   ; return n*factorial(n-1)
-  ((x integer) <- sub (n integer) (1 literal))
+  ((x integer) <- subtract (n integer) (1 literal))
   ((subresult integer) <- factorial (x integer))
-  ((result integer) <- mul (subresult integer) (n integer))
+  ((result integer) <- multiply (subresult integer) (n integer))
   (reply (result integer))
 ])
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-07-01 01:59:58 +0000